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

#import <Foundation/Foundation.h>

#import "MTRBaseClusters_Internal.h"
#import "MTRBaseDevice_Internal.h"
#import "MTRCallbackBridgeBase.h"
#import "MTRClusterStateCacheContainer_Internal.h"
#import "MTRCluster_Internal.h"
#import "MTRCommandPayloadsObjc.h"
#import "MTRDefines_Internal.h"
#import "MTRDevice_Internal.h"
#import "MTRStructsObjc.h"
#import "NSDataSpanConversion.h"
#import "NSStringSpanConversion.h"

#include <app-common/zap-generated/cluster-objects.h>
#include <app/data-model/ListLargeSystemExtensions.h>
#include <app/util/im-client-callbacks.h>
#include <controller/CHIPCluster.h>
#include <platform/CHIPDeviceLayer.h>

#include <type_traits>

using chip::Callback::Callback;
using chip::Callback::Cancelable;
using namespace chip::app::Clusters;
using chip::Optional;
using chip::SessionHandle;
using chip::Messaging::ExchangeManager;
using chip::System::Clock::Seconds16;
using chip::System::Clock::Timeout;

typedef void (*DefaultSuccessCallbackType)(void *);

class MTRDefaultSuccessCallbackBridge : public MTRCallbackBridge<DefaultSuccessCallback> {
public:
    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action)
        : MTRCallbackBridge<DefaultSuccessCallback>(queue, handler, action, OnSuccessFn) {};

    static void OnSuccessFn(void * context)
    {
        DispatchSuccess(context, nil);
    }
};

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

- (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRIdentifyClusterIdentifyParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Identify::Commands::Identify::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRIdentifyClusterTriggerEffectParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Identify::Commands::TriggerEffect::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeIdentifyTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeIdentifyTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeIdentifyTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeIdentifyTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeIdentifyTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Identify::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeIdentifyTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIdentifyTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeIdentifyTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIdentifyTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeIdentifyTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIdentifyTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params completion:(void (^)(MTRGroupsClusterAddGroupResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGroupsClusterAddGroupParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Groups::Commands::AddGroup::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGroupsClusterAddGroupResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params completion:(void (^)(MTRGroupsClusterViewGroupResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGroupsClusterViewGroupParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Groups::Commands::ViewGroup::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGroupsClusterViewGroupResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *)params completion:(void (^)(MTRGroupsClusterGetGroupMembershipResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGroupsClusterGetGroupMembershipParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Groups::Commands::GetGroupMembership::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGroupsClusterGetGroupMembershipResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params completion:(void (^)(MTRGroupsClusterRemoveGroupResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGroupsClusterRemoveGroupParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Groups::Commands::RemoveGroup::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGroupsClusterRemoveGroupResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)removeAllGroupsWithCompletion:(MTRStatusCompletion)completion
{
    [self removeAllGroupsWithParams:nil completion:completion];
}
- (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRGroupsClusterRemoveAllGroupsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Groups::Commands::RemoveAllGroups::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRGroupsClusterAddGroupIfIdentifyingParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Groups::Commands::AddGroupIfIdentifying::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeNameSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNameSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNameSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Groups::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterGroups (Deprecated)

- (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params completionHandler:(void (^)(MTRGroupsClusterAddGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self addGroupWithParams:params completion:
                                        ^(MTRGroupsClusterAddGroupResponseParams * _Nullable data, NSError * _Nullable error) {
                                            // Cast is safe because subclass does not add any selectors.
                                            completionHandler(static_cast<MTRGroupsClusterAddGroupResponseParams *>(data), error);
                                        }];
}
- (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params completionHandler:(void (^)(MTRGroupsClusterViewGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self viewGroupWithParams:params completion:
                                         ^(MTRGroupsClusterViewGroupResponseParams * _Nullable data, NSError * _Nullable error) {
                                             // Cast is safe because subclass does not add any selectors.
                                             completionHandler(static_cast<MTRGroupsClusterViewGroupResponseParams *>(data), error);
                                         }];
}
- (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *)params completionHandler:(void (^)(MTRGroupsClusterGetGroupMembershipResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self getGroupMembershipWithParams:params completion:
                                                  ^(MTRGroupsClusterGetGroupMembershipResponseParams * _Nullable data, NSError * _Nullable error) {
                                                      // Cast is safe because subclass does not add any selectors.
                                                      completionHandler(static_cast<MTRGroupsClusterGetGroupMembershipResponseParams *>(data), error);
                                                  }];
}
- (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params completionHandler:(void (^)(MTRGroupsClusterRemoveGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self removeGroupWithParams:params completion:
                                           ^(MTRGroupsClusterRemoveGroupResponseParams * _Nullable data, NSError * _Nullable error) {
                                               // Cast is safe because subclass does not add any selectors.
                                               completionHandler(static_cast<MTRGroupsClusterRemoveGroupResponseParams *>(data), error);
                                           }];
}
- (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self removeAllGroupsWithParams:params completion:
                                               completionHandler];
}
- (void)removeAllGroupsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self removeAllGroupsWithParams:nil completionHandler: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:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNameSupportWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)offWithCompletion:(MTRStatusCompletion)completion
{
    [self offWithParams:nil completion:completion];
}
- (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROnOffClusterOffParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OnOff::Commands::Off::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)onWithCompletion:(MTRStatusCompletion)completion
{
    [self onWithParams:nil completion:completion];
}
- (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROnOffClusterOnParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OnOff::Commands::On::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)toggleWithCompletion:(MTRStatusCompletion)completion
{
    [self toggleWithParams:nil completion:completion];
}
- (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROnOffClusterToggleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OnOff::Commands::Toggle::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROnOffClusterOffWithEffectParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OnOff::Commands::OffWithEffect::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)onWithRecallGlobalSceneWithCompletion:(MTRStatusCompletion)completion
{
    [self onWithRecallGlobalSceneWithParams:nil completion:completion];
}
- (void)onWithRecallGlobalSceneWithParams:(MTROnOffClusterOnWithRecallGlobalSceneParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROnOffClusterOnWithRecallGlobalSceneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OnOff::Commands::OnWithRecallGlobalScene::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROnOffClusterOnWithTimedOffParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OnOff::Commands::OnWithTimedOff::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOnOffWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnOffWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGlobalSceneControlWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGlobalSceneControlWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGlobalSceneControlWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOffWaitTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOffWaitTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpOnOffWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOnOff (Deprecated)

- (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self offWithParams:params completion:
                                   completionHandler];
}
- (void)offWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self offWithParams:nil completionHandler:completionHandler];
}
- (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self onWithParams:params completion:
                                  completionHandler];
}
- (void)onWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self onWithParams:nil completionHandler:completionHandler];
}
- (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self toggleWithParams:params completion:
                                      completionHandler];
}
- (void)toggleWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self toggleWithParams:nil completionHandler: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 completionHandler: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:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnOffWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeGlobalSceneControlWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGlobalSceneControlWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeGlobalSceneControlWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGlobalSceneControlWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeOnTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeOnTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeOffWaitTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOffWaitTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeOffWaitTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOffWaitTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeStartUpOnOffWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpOnOffWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeStartUpOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpOnOffWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeSwitchTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSwitchTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSwitchTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSwitchActionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSwitchActionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOnOffSwitchConfiguration (Deprecated)

- (void)readAttributeSwitchTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeSwitchTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeSwitchActionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchActionsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeSwitchActionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchActionsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterMoveToLevelParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::MoveToLevel::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterMoveParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::Move::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stepWithParams:(MTRLevelControlClusterStepParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterStepParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::Step::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopWithParams:(MTRLevelControlClusterStopParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterStopParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::Stop::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterMoveToLevelWithOnOffParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::MoveToLevelWithOnOff::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterMoveWithOnOffParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::MoveWithOnOff::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterStepWithOnOffParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::StepWithOnOff::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterStopWithOnOffParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::StopWithOnOff::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFrequencyParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLevelControlClusterMoveToClosestFrequencyParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LevelControl::Commands::MoveToClosestFrequency::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRemainingTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOptionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnOffTransitionTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnTransitionTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOffTransitionTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultMoveRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultMoveRateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpCurrentLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeMaxLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeCurrentFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFrequencyWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeCurrentFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFrequencyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMinFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinFrequencyWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeMinFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinFrequencyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeMaxFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFrequencyWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeMaxFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFrequencyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeOptionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeOnOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnOffTransitionTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeOnOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnOffTransitionTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeOnLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeOnLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeOnTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTransitionTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeOnTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTransitionTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOffTransitionTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOffTransitionTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeDefaultMoveRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultMoveRateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeDefaultMoveRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultMoveRateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeStartUpCurrentLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpCurrentLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeStartUpCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpCurrentLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeActiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveTextWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInactiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInactiveTextWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOutOfServiceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOutOfServiceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePolarityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePolarityWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePolarityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePresentValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePresentValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReliabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReliabilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStatusFlagsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStatusFlagsWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStatusFlagsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApplicationTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApplicationTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApplicationTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBinaryInputBasic (Deprecated)

- (void)readAttributeActiveTextWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTextWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeActiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTextWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeDescriptionWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeInactiveTextWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInactiveTextWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeInactiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInactiveTextWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeOutOfServiceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutOfServiceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeOutOfServiceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutOfServiceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributePolarityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePolarityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributePolarityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePolarityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributePresentValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePresentValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributePresentValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePresentValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeReliabilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReliabilityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeReliabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReliabilityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeStatusFlagsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusFlagsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeStatusFlagsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusFlagsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeApplicationTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeApplicationTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterPulseWidthModulation

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PulseWidthModulation::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PulseWidthModulation::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PulseWidthModulation::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PulseWidthModulation::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PulseWidthModulation::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PulseWidthModulation::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PulseWidthModulation::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDescriptor

- (void)readAttributeDeviceTypeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDeviceTypeListWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDeviceTypeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeServerListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeServerListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeServerListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClientListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClientListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClientListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePartsListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePartsListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePartsListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTagListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::TagList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTagListWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::TagList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTagListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::TagList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDescriptor (Deprecated)

- (void)readAttributeDeviceListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDeviceTypeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeDeviceListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDeviceTypeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeServerListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeServerListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeServerListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeServerListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClientListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClientListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeClientListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClientListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}

- (void)readAttributePartsListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartsListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePartsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartsListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeBindingWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::Binding::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Binding::Attributes::Binding::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBindingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::Binding::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Binding::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBinding (Deprecated)

- (void)readAttributeBindingWithParams:(MTRReadParams * _Nullable)params completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBindingWithParams:params completion:
                                                    ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                        // Cast is safe because subclass does not add any selectors.
                                                        completionHandler(static_cast<NSArray *>(value), error);
                                                    }];
}
- (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:
                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeBindingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBindingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeACLWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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: [MTRAccessControlClusterAccessControlEntryStruct class]] ) {
                  // Wrong kind of value.
                  return CHIP_ERROR_INVALID_ARGUMENT;
                }
                auto element_0 = (MTRAccessControlClusterAccessControlEntryStruct *)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: [MTRAccessControlClusterAccessControlTargetStruct class]] ) {
                   // Wrong kind of value.
                   return CHIP_ERROR_INVALID_ARGUMENT;
                 }
                 auto element_3 = (MTRAccessControlClusterAccessControlTargetStruct *)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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeExtensionWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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: [MTRAccessControlClusterAccessControlExtensionStruct class]] ) {
                  // Wrong kind of value.
                  return CHIP_ERROR_INVALID_ARGUMENT;
                }
                auto element_0 = (MTRAccessControlClusterAccessControlExtensionStruct *)value[i_0];
                       listHolder_0->mList[i_0].data = 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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeExtensionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSubjectsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSubjectsPerAccessControlEntryWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSubjectsPerAccessControlEntryWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTargetsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTargetsPerAccessControlEntryWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTargetsPerAccessControlEntryWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAccessControlEntriesPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAccessControlEntriesPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAccessControlEntriesPerFabricWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterAccessControl (Deprecated)

- (void)readAttributeAclWithParams:(MTRReadParams * _Nullable)params completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACLWithParams:params completion:
                                                ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                    // Cast is safe because subclass does not add any selectors.
                                                    completionHandler(static_cast<NSArray *>(value), error);
                                                }];
}
- (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:
                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                     }];
}
+ (void)readAttributeAclWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACLWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                        }];
}

- (void)readAttributeExtensionWithParams:(MTRReadParams * _Nullable)params completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtensionWithParams:params completion:
                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                          // Cast is safe because subclass does not add any selectors.
                                                          completionHandler(static_cast<NSArray *>(value), error);
                                                      }];
}
- (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:
                                                                                                                           ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeExtensionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtensionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeSubjectsPerAccessControlEntryWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSubjectsPerAccessControlEntryWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeSubjectsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSubjectsPerAccessControlEntryWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeTargetsPerAccessControlEntryWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetsPerAccessControlEntryWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeTargetsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetsPerAccessControlEntryWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeAccessControlEntriesPerFabricWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAccessControlEntriesPerFabricWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeAccessControlEntriesPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAccessControlEntriesPerFabricWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)instantActionWithParams:(MTRActionsClusterInstantActionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterInstantActionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::InstantAction::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWithTransitionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterInstantActionWithTransitionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::InstantActionWithTransition::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterStartActionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::StartAction::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterStartActionWithDurationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::StartActionWithDuration::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterStopActionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::StopAction::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterPauseActionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::PauseAction::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterPauseActionWithDurationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::PauseActionWithDuration::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterResumeActionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::ResumeAction::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterEnableActionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::EnableAction::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDurationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterEnableActionWithDurationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::EnableActionWithDuration::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterDisableActionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::DisableAction::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithDurationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActionsClusterDisableActionWithDurationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Actions::Commands::DisableActionWithDuration::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeActionListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActionListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActionListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEndpointListsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEndpointListsWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEndpointListsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSetupURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSetupURLWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSetupURLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeActionListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActionListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeEndpointListsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEndpointListsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeEndpointListsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEndpointListsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeSetupURLWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetupURLWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSString *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeSetupURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetupURLWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterBasicInformation

- (void)mfgSpecificPingWithCompletion:(MTRStatusCompletion)completion
{
    [self mfgSpecificPingWithParams:nil completion:completion];
}
- (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRBasicClusterMfgSpecificPingParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = BasicInformation::Commands::MfgSpecificPing::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeDataModelRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::DataModelRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDataModelRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::DataModelRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDataModelRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::DataModelRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::VendorName::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::VendorName::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVendorNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::VendorName::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::VendorID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::VendorID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVendorIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::VendorID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductName::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::ProductName::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductName::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::ProductID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::NodeLabel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = BasicInformation::Attributes::NodeLabel::TypeInfo;
        TypeInfo::Type cppValue;
          cppValue = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BasicInformation::Attributes::NodeLabel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNodeLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::NodeLabel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLocationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::Location::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = BasicInformation::Attributes::Location::TypeInfo;
        TypeInfo::Type cppValue;
          cppValue = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BasicInformation::Attributes::Location::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLocationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::Location::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::HardwareVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::HardwareVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHardwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::HardwareVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::HardwareVersionString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::HardwareVersionString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHardwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::HardwareVersionString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SoftwareVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::SoftwareVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSoftwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SoftwareVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SoftwareVersionString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::SoftwareVersionString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSoftwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SoftwareVersionString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ManufacturingDate::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::ManufacturingDate::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeManufacturingDateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ManufacturingDate::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::PartNumber::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::PartNumber::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePartNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::PartNumber::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductURL::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::ProductURL::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductURLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductURL::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductLabel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::ProductLabel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductLabel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SerialNumber::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::SerialNumber::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSerialNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SerialNumber::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLocalConfigDisabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::LocalConfigDisabled::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = BasicInformation::Attributes::LocalConfigDisabled::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.boolValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BasicInformation::Attributes::LocalConfigDisabled::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLocalConfigDisabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::LocalConfigDisabled::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::Reachable::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::Reachable::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReachableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::Reachable::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::UniqueID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::UniqueID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUniqueIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::UniqueID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCapabilityMinimaWithCompletion:(void (^)(MTRBasicInformationClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::CapabilityMinima::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCapabilityMinimaWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(MTRBasicInformationClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::CapabilityMinima::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCapabilityMinimaWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRBasicInformationClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::CapabilityMinima::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductAppearanceWithCompletion:(void (^)(MTRBasicInformationClusterProductAppearanceStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductAppearance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductAppearanceWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(MTRBasicInformationClusterProductAppearanceStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::ProductAppearance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductAppearanceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRBasicInformationClusterProductAppearanceStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ProductAppearance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSpecificationVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SpecificationVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSpecificationVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::SpecificationVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSpecificationVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::SpecificationVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxPathsPerInvokeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::MaxPathsPerInvoke::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxPathsPerInvokeWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::MaxPathsPerInvoke::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxPathsPerInvokeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::MaxPathsPerInvoke::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BasicInformation::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BasicInformation::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBasic
@end

@implementation MTRBaseClusterBasic (Deprecated)

- (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self mfgSpecificPingWithParams:params completion:
                                               completionHandler];
}
- (void)mfgSpecificPingWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self mfgSpecificPingWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributeDataModelRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDataModelRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeDataModelRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDataModelRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeVendorNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeVendorIDWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeProductNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeProductIDWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeNodeLabelWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSString *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeLocationWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSString *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeLocationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeHardwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeHardwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeSoftwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeSoftwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeManufacturingDateWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePartNumberWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeProductURLWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeProductLabelWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeSerialNumberWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeLocalConfigDisabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalConfigDisabledWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeLocalConfigDisabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalConfigDisabledWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeReachableWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeUniqueIDWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSString *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeCapabilityMinimaWithCompletionHandler:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCapabilityMinimaWithCompletion:
              ^(MTRBasicInformationClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRBasicClusterCapabilityMinimaStruct *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(MTRBasicInformationClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<MTRBasicClusterCapabilityMinimaStruct *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeCapabilityMinimaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCapabilityMinimaWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(MTRBasicInformationClusterCapabilityMinimaStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<MTRBasicClusterCapabilityMinimaStruct *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)queryImageWithParams:(MTROTASoftwareUpdateProviderClusterQueryImageParams *)params completion:(void (^)(MTROTASoftwareUpdateProviderClusterQueryImageResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROTASoftwareUpdateProviderClusterQueryImageParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OtaSoftwareUpdateProvider::Commands::QueryImage::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROTASoftwareUpdateProviderClusterQueryImageResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)applyUpdateRequestWithParams:(MTROTASoftwareUpdateProviderClusterApplyUpdateRequestParams *)params completion:(void (^)(MTROTASoftwareUpdateProviderClusterApplyUpdateResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROTASoftwareUpdateProviderClusterApplyUpdateRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROTASoftwareUpdateProviderClusterApplyUpdateResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)notifyUpdateAppliedWithParams:(MTROTASoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROTASoftwareUpdateProviderClusterNotifyUpdateAppliedParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOtaSoftwareUpdateProvider
@end

@implementation MTRBaseClusterOtaSoftwareUpdateProvider (Deprecated)

- (void)queryImageWithParams:(MTROtaSoftwareUpdateProviderClusterQueryImageParams *)params completionHandler:(void (^)(MTROtaSoftwareUpdateProviderClusterQueryImageResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self queryImageWithParams:params completion:
                                          ^(MTROTASoftwareUpdateProviderClusterQueryImageResponseParams * _Nullable data, NSError * _Nullable error) {
                                              // Cast is safe because subclass does not add any selectors.
                                              completionHandler(static_cast<MTROtaSoftwareUpdateProviderClusterQueryImageResponseParams *>(data), error);
                                          }];
}
- (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUpdateRequestParams *)params completionHandler:(void (^)(MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self applyUpdateRequestWithParams:params completion:
                                                  ^(MTROTASoftwareUpdateProviderClusterApplyUpdateResponseParams * _Nullable data, NSError * _Nullable error) {
                                                      // Cast is safe because subclass does not add any selectors.
                                                      completionHandler(static_cast<MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseParams *>(data), error);
                                                  }];
}
- (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self notifyUpdateAppliedWithParams:params completion:
                                                   completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)announceOTAProviderWithParams:(MTROTASoftwareUpdateRequestorClusterAnnounceOTAProviderParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROTASoftwareUpdateRequestorClusterAnnounceOTAProviderParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OtaSoftwareUpdateRequestor::Commands::AnnounceOTAProvider::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeDefaultOTAProvidersWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOTAProviders::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOTAProviders::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultOTAProvidersWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOTAProviders::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUpdatePossibleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUpdatePossibleWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUpdatePossibleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUpdateStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUpdateStateWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUpdateStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUpdateStateProgressWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUpdateStateProgressWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUpdateStateProgressWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOtaSoftwareUpdateRequestor
@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:
                                                                ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                    // Cast is safe because subclass does not add any selectors.
                                                                    completionHandler(static_cast<NSArray *>(value), error);
                                                                }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeDefaultOtaProvidersWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultOTAProvidersWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeUpdatePossibleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdatePossibleWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeUpdatePossibleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdatePossibleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeUpdateStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeUpdateStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeUpdateStateProgressWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateProgressWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeUpdateStateProgressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateProgressWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeActiveLocaleWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveLocaleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedLocalesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedLocalesWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedLocalesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LocalizationConfiguration::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterLocalizationConfiguration (Deprecated)

- (void)readAttributeActiveLocaleWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveLocaleWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeActiveLocaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveLocaleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeSupportedLocalesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedLocalesWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeSupportedLocalesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedLocalesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeHourFormatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHourFormatWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveCalendarTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveCalendarTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedCalendarTypesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedCalendarTypesWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedCalendarTypesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeFormatLocalization::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterTimeFormatLocalization (Deprecated)

- (void)readAttributeHourFormatWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHourFormatWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeHourFormatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHourFormatWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeActiveCalendarTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCalendarTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeActiveCalendarTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCalendarTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeSupportedCalendarTypesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedCalendarTypesWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeSupportedCalendarTypesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedCalendarTypesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeTemperatureUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTemperatureUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitLocalization::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterUnitLocalization (Deprecated)

- (void)readAttributeTemperatureUnitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureUnitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeTemperatureUnitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureUnitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeSourcesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSourcesWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSourcesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSourceConfiguration::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPowerSourceConfiguration (Deprecated)

- (void)readAttributeSourcesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSourcesWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeSourcesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSourcesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOrderWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOrderWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOrderWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiredAssessedInputVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiredAssessedInputVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiredAssessedInputVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiredAssessedInputFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiredAssessedInputFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiredAssessedInputFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiredCurrentTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiredCurrentTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiredCurrentTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiredAssessedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiredAssessedCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiredAssessedCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiredNominalVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiredNominalVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiredNominalVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiredMaximumCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiredMaximumCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiredMaximumCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiredPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiredPresentWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiredPresentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveWiredFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveWiredFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveWiredFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatPercentRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatPercentRemainingWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatPercentRemainingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatTimeRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatTimeRemainingWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatTimeRemainingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatChargeLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatChargeLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatChargeLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatReplacementNeededWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatReplacementNeededWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatReplacementNeededWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatReplaceabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatReplaceabilityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatReplaceabilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatPresentWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatPresentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveBatFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveBatFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveBatFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatReplacementDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatReplacementDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatReplacementDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatCommonDesignationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatCommonDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatCommonDesignationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatANSIDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatANSIDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatANSIDesignationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatIECDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatIECDesignationWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatIECDesignationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatApprovedChemistryWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatApprovedChemistryWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatApprovedChemistryWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatQuantityWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatQuantityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatChargeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatChargeStateWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatChargeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatTimeToFullChargeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatTimeToFullChargeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatTimeToFullChargeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatFunctionalWhileChargingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatFunctionalWhileChargingWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatFunctionalWhileChargingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatChargingCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatChargingCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatChargingCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveBatChargeFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveBatChargeFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveBatChargeFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEndpointListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::EndpointList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEndpointListWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::EndpointList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEndpointListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::EndpointList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPowerSource (Deprecated)

- (void)readAttributeStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeOrderWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOrderWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeOrderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOrderWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeDescriptionWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeWiredAssessedInputVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeWiredAssessedInputVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeWiredAssessedInputFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputFrequencyWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeWiredAssessedInputFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputFrequencyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeWiredCurrentTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredCurrentTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeWiredCurrentTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredCurrentTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeWiredAssessedCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeWiredAssessedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeWiredNominalVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredNominalVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeWiredNominalVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredNominalVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeWiredMaximumCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredMaximumCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeWiredMaximumCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredMaximumCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeWiredPresentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredPresentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeWiredPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredPresentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeActiveWiredFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveWiredFaultsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeActiveWiredFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveWiredFaultsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeBatVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeBatVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeBatPercentRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPercentRemainingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeBatPercentRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPercentRemainingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeBatTimeRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeRemainingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeBatTimeRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeRemainingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeBatChargeLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeBatChargeLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeBatReplacementNeededWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementNeededWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeBatReplacementNeededWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementNeededWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeBatReplaceabilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplaceabilityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeBatReplaceabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplaceabilityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeBatPresentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPresentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeBatPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPresentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeActiveBatFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatFaultsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeActiveBatFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatFaultsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeBatReplacementDescriptionWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementDescriptionWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeBatReplacementDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementDescriptionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeBatCommonDesignationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCommonDesignationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeBatCommonDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCommonDesignationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeBatANSIDesignationWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatANSIDesignationWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeBatANSIDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatANSIDesignationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeBatIECDesignationWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatIECDesignationWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeBatIECDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatIECDesignationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeBatApprovedChemistryWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatApprovedChemistryWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeBatApprovedChemistryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatApprovedChemistryWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeBatCapacityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCapacityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeBatCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCapacityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeBatQuantityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatQuantityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeBatQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatQuantityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeBatChargeStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeStateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeBatChargeStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeStateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeBatTimeToFullChargeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeToFullChargeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeBatTimeToFullChargeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeToFullChargeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeBatFunctionalWhileChargingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatFunctionalWhileChargingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeBatFunctionalWhileChargingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatFunctionalWhileChargingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeBatChargingCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargingCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeBatChargingCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargingCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeActiveBatChargeFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatChargeFaultsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeActiveBatChargeFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatChargeFaultsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *)params completion:(void (^)(MTRGeneralCommissioningClusterArmFailSafeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGeneralCommissioningClusterArmFailSafeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GeneralCommissioning::Commands::ArmFailSafe::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGeneralCommissioningClusterArmFailSafeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulatoryConfigParams *)params completion:(void (^)(MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGeneralCommissioningClusterSetRegulatoryConfigParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GeneralCommissioning::Commands::SetRegulatoryConfig::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (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
{
    if (params == nil) {
        params = [[MTRGeneralCommissioningClusterCommissioningCompleteParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GeneralCommissioning::Commands::CommissioningComplete::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGeneralCommissioningClusterCommissioningCompleteResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeBreadcrumbWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBreadcrumbWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBasicCommissioningInfoWithCompletion:(void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBasicCommissioningInfoWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBasicCommissioningInfoWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRegulatoryConfigWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRegulatoryConfigWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRegulatoryConfigWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLocationCapabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLocationCapabilityWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLocationCapabilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportsConcurrentConnectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportsConcurrentConnectionWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportsConcurrentConnectionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterGeneralCommissioning (Deprecated)

- (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *)params completionHandler:(void (^)(MTRGeneralCommissioningClusterArmFailSafeResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self armFailSafeWithParams:params completion:
                                           ^(MTRGeneralCommissioningClusterArmFailSafeResponseParams * _Nullable data, NSError * _Nullable error) {
                                               // Cast is safe because subclass does not add any selectors.
                                               completionHandler(static_cast<MTRGeneralCommissioningClusterArmFailSafeResponseParams *>(data), error);
                                           }];
}
- (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulatoryConfigParams *)params completionHandler:(void (^)(MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self setRegulatoryConfigWithParams:params completion:
                                                   ^(MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams * _Nullable data, NSError * _Nullable error) {
                                                       // Cast is safe because subclass does not add any selectors.
                                                       completionHandler(static_cast<MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams *>(data), error);
                                                   }];
}
- (void)commissioningCompleteWithParams:(MTRGeneralCommissioningClusterCommissioningCompleteParams * _Nullable)params completionHandler:(void (^)(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self commissioningCompleteWithParams:params completion:
                                                     ^(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data, NSError * _Nullable error) {
                                                         // Cast is safe because subclass does not add any selectors.
                                                         completionHandler(static_cast<MTRGeneralCommissioningClusterCommissioningCompleteResponseParams *>(data), error);
                                                     }];
}
- (void)commissioningCompleteWithCompletionHandler:(void (^)(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self commissioningCompleteWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributeBreadcrumbWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBreadcrumbWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeBreadcrumbWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBreadcrumbWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeBasicCommissioningInfoWithCompletionHandler:(void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBasicCommissioningInfoWithCompletion:
              ^(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRGeneralCommissioningClusterBasicCommissioningInfo *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<MTRGeneralCommissioningClusterBasicCommissioningInfo *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeBasicCommissioningInfoWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBasicCommissioningInfoWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<MTRGeneralCommissioningClusterBasicCommissioningInfo *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeRegulatoryConfigWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRegulatoryConfigWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeRegulatoryConfigWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRegulatoryConfigWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeLocationCapabilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationCapabilityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeLocationCapabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationCapabilityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeSupportsConcurrentConnectionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportsConcurrentConnectionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeSupportsConcurrentConnectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportsConcurrentConnectionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)scanNetworksWithCompletion:(void (^)(MTRNetworkCommissioningClusterScanNetworksResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self scanNetworksWithParams:nil completion:completion];
}
- (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams * _Nullable)params completion:(void (^)(MTRNetworkCommissioningClusterScanNetworksResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRNetworkCommissioningClusterScanNetworksParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = NetworkCommissioning::Commands::ScanNetworks::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRNetworkCommissioningClusterScanNetworksResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams *)params completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRNetworkCommissioningClusterNetworkConfigResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams *)params completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRNetworkCommissioningClusterNetworkConfigResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkParams *)params completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRNetworkCommissioningClusterRemoveNetworkParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = NetworkCommissioning::Commands::RemoveNetwork::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRNetworkCommissioningClusterNetworkConfigResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkParams *)params completion:(void (^)(MTRNetworkCommissioningClusterConnectNetworkResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRNetworkCommissioningClusterConnectNetworkParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = NetworkCommissioning::Commands::ConnectNetwork::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRNetworkCommissioningClusterConnectNetworkResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkParams *)params completion:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRNetworkCommissioningClusterReorderNetworkParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = NetworkCommissioning::Commands::ReorderNetwork::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRNetworkCommissioningClusterNetworkConfigResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)queryIdentityWithParams:(MTRNetworkCommissioningClusterQueryIdentityParams *)params completion:(void (^)(MTRNetworkCommissioningClusterQueryIdentityResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRNetworkCommissioningClusterQueryIdentityParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = NetworkCommissioning::Commands::QueryIdentity::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRNetworkCommissioningClusterQueryIdentityResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeMaxNetworksWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxNetworksWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxNetworksWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNetworksWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNetworksWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNetworksWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScanMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScanMaxTimeSecondsWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScanMaxTimeSecondsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeConnectMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeConnectMaxTimeSecondsWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeConnectMaxTimeSecondsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInterfaceEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInterfaceEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLastNetworkingStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLastNetworkingStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLastNetworkingStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLastNetworkIDWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLastNetworkIDWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLastNetworkIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLastConnectErrorValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLastConnectErrorValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLastConnectErrorValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedWiFiBandsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::SupportedWiFiBands::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedWiFiBandsWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::SupportedWiFiBands::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedWiFiBandsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::SupportedWiFiBands::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedThreadFeaturesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::SupportedThreadFeatures::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedThreadFeaturesWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::SupportedThreadFeatures::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedThreadFeaturesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::SupportedThreadFeatures::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeThreadVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ThreadVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeThreadVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::ThreadVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeThreadVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ThreadVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterNetworkCommissioning (Deprecated)

- (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams * _Nullable)params completionHandler:(void (^)(MTRNetworkCommissioningClusterScanNetworksResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self scanNetworksWithParams:params completion:
                                            ^(MTRNetworkCommissioningClusterScanNetworksResponseParams * _Nullable data, NSError * _Nullable error) {
                                                // Cast is safe because subclass does not add any selectors.
                                                completionHandler(static_cast<MTRNetworkCommissioningClusterScanNetworksResponseParams *>(data), error);
                                            }];
}
- (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams *)params completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self addOrUpdateWiFiNetworkWithParams:params completion:
                                                      ^(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error) {
                                                          // Cast is safe because subclass does not add any selectors.
                                                          completionHandler(static_cast<MTRNetworkCommissioningClusterNetworkConfigResponseParams *>(data), error);
                                                      }];
}
- (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams *)params completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self addOrUpdateThreadNetworkWithParams:params completion:
                                                        ^(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error) {
                                                            // Cast is safe because subclass does not add any selectors.
                                                            completionHandler(static_cast<MTRNetworkCommissioningClusterNetworkConfigResponseParams *>(data), error);
                                                        }];
}
- (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkParams *)params completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self removeNetworkWithParams:params completion:
                                             ^(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error) {
                                                 // Cast is safe because subclass does not add any selectors.
                                                 completionHandler(static_cast<MTRNetworkCommissioningClusterNetworkConfigResponseParams *>(data), error);
                                             }];
}
- (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkParams *)params completionHandler:(void (^)(MTRNetworkCommissioningClusterConnectNetworkResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self connectNetworkWithParams:params completion:
                                              ^(MTRNetworkCommissioningClusterConnectNetworkResponseParams * _Nullable data, NSError * _Nullable error) {
                                                  // Cast is safe because subclass does not add any selectors.
                                                  completionHandler(static_cast<MTRNetworkCommissioningClusterConnectNetworkResponseParams *>(data), error);
                                              }];
}
- (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkParams *)params completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self reorderNetworkWithParams:params completion:
                                              ^(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data, NSError * _Nullable error) {
                                                  // Cast is safe because subclass does not add any selectors.
                                                  completionHandler(static_cast<MTRNetworkCommissioningClusterNetworkConfigResponseParams *>(data), error);
                                              }];
}

- (void)readAttributeMaxNetworksWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxNetworksWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeMaxNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxNetworksWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeNetworksWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworksWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworksWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeScanMaxTimeSecondsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScanMaxTimeSecondsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeScanMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScanMaxTimeSecondsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeConnectMaxTimeSecondsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeConnectMaxTimeSecondsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeConnectMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeConnectMaxTimeSecondsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeInterfaceEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInterfaceEnabledWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeInterfaceEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInterfaceEnabledWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeLastNetworkingStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkingStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeLastNetworkingStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkingStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeLastNetworkIDWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkIDWithCompletion:
              ^(NSData * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSData *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSData *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeLastNetworkIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSData *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeLastConnectErrorValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastConnectErrorValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeLastConnectErrorValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastConnectErrorValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsRequestParams *)params completion:(void (^)(MTRDiagnosticLogsClusterRetrieveLogsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDiagnosticLogsClusterRetrieveLogsRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DiagnosticLogs::Commands::RetrieveLogsRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDiagnosticLogsClusterRetrieveLogsResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DiagnosticLogs::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDiagnosticLogs (Deprecated)

- (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsRequestParams *)params completionHandler:(void (^)(MTRDiagnosticLogsClusterRetrieveLogsResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self retrieveLogsRequestWithParams:params completion:
                                                   ^(MTRDiagnosticLogsClusterRetrieveLogsResponseParams * _Nullable data, NSError * _Nullable error) {
                                                       // Cast is safe because subclass does not add any selectors.
                                                       completionHandler(static_cast<MTRDiagnosticLogsClusterRetrieveLogsResponseParams *>(data), error);
                                                   }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTriggerParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRGeneralDiagnosticsClusterTestEventTriggerParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GeneralDiagnostics::Commands::TestEventTrigger::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)timeSnapshotWithCompletion:(void (^)(MTRGeneralDiagnosticsClusterTimeSnapshotResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self timeSnapshotWithParams:nil completion:completion];
}
- (void)timeSnapshotWithParams:(MTRGeneralDiagnosticsClusterTimeSnapshotParams * _Nullable)params completion:(void (^)(MTRGeneralDiagnosticsClusterTimeSnapshotResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGeneralDiagnosticsClusterTimeSnapshotParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GeneralDiagnostics::Commands::TimeSnapshot::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGeneralDiagnosticsClusterTimeSnapshotResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)payloadTestRequestWithParams:(MTRGeneralDiagnosticsClusterPayloadTestRequestParams *)params completion:(void (^)(MTRGeneralDiagnosticsClusterPayloadTestResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGeneralDiagnosticsClusterPayloadTestRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GeneralDiagnostics::Commands::PayloadTestRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGeneralDiagnosticsClusterPayloadTestResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeNetworkInterfacesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNetworkInterfacesWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNetworkInterfacesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRebootCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRebootCountWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRebootCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUpTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUpTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUpTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTotalOperationalHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTotalOperationalHoursWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTotalOperationalHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBootReasonWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::BootReason::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBootReasonWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::BootReason::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBootReasonWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::BootReason::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveHardwareFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveHardwareFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveHardwareFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveRadioFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveRadioFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveRadioFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveNetworkFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveNetworkFaultsWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveNetworkFaultsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTestEventTriggersEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTestEventTriggersEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTestEventTriggersEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeNetworkInterfacesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworkInterfacesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeRebootCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRebootCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeRebootCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRebootCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeUpTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeUpTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeTotalOperationalHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalOperationalHoursWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeTotalOperationalHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalOperationalHoursWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeBootReasonsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBootReasonWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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 subscribeAttributeBootReasonWithParams:subscribeParams subscriptionEstablished:subscriptionEstablishedHandler reportHandler:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeBootReasonsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBootReasonWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeActiveHardwareFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveHardwareFaultsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeActiveHardwareFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveHardwareFaultsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeActiveRadioFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveRadioFaultsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeActiveRadioFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveRadioFaultsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeActiveNetworkFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeActiveNetworkFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeTestEventTriggersEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTestEventTriggersEnabledWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeTestEventTriggersEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTestEventTriggersEnabledWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)resetWatermarksWithCompletion:(MTRStatusCompletion)completion
{
    [self resetWatermarksWithParams:nil completion:completion];
}
- (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRSoftwareDiagnosticsClusterResetWatermarksParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = SoftwareDiagnostics::Commands::ResetWatermarks::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeThreadMetricsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeThreadMetricsWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeThreadMetricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentHeapFreeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentHeapFreeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentHeapFreeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentHeapUsedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentHeapUsedWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentHeapUsedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentHeapHighWatermarkWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentHeapHighWatermarkWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentHeapHighWatermarkWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterSoftwareDiagnostics (Deprecated)

- (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetWatermarksWithParams:params completion:
                                               completionHandler];
}
- (void)resetWatermarksWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetWatermarksWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributeThreadMetricsWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThreadMetricsWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeThreadMetricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThreadMetricsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeCurrentHeapFreeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapFreeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeCurrentHeapFreeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapFreeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeCurrentHeapUsedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapUsedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeCurrentHeapUsedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapUsedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeCurrentHeapHighWatermarkWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapHighWatermarkWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeCurrentHeapHighWatermarkWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapHighWatermarkWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)resetCountsWithCompletion:(MTRStatusCompletion)completion
{
    [self resetCountsWithParams:nil completion:completion];
}
- (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThreadNetworkDiagnosticsClusterResetCountsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ThreadNetworkDiagnostics::Commands::ResetCounts::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeChannelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChannelWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChannelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRoutingRoleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRoutingRoleWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRoutingRoleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNetworkNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNetworkNameWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNetworkNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePanIdWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePanIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeExtendedPanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeExtendedPanIdWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeExtendedPanIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeshLocalPrefixWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeshLocalPrefixWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeshLocalPrefixWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOverrunCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNeighborTableWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTable::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNeighborTableWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTable::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNeighborTableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTable::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRouteTableWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTable::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRouteTableWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTable::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRouteTableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTable::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePartitionIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePartitionIdWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePartitionIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWeightingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWeightingWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWeightingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDataVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDataVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStableDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStableDataVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStableDataVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLeaderRouterIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLeaderRouterIdWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLeaderRouterIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDetachedRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDetachedRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDetachedRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeChildRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChildRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChildRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRouterRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRouterRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRouterRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLeaderRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLeaderRoleCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLeaderRoleCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttachAttemptCountWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttachAttemptCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePartitionIdChangeCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePartitionIdChangeCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePartitionIdChangeCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBetterPartitionAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBetterPartitionAttachAttemptCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBetterPartitionAttachAttemptCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeParentChangeCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeParentChangeCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeParentChangeCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxTotalCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxUnicastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxUnicastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxBroadcastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxBroadcastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxAckRequestedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxAckRequestedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxAckedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxAckedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxAckedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxNoAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxNoAckRequestedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxNoAckRequestedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxDataCountWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxDataCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxDataPollCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxDataPollCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxBeaconCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxBeaconRequestCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxBeaconRequestCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxOtherCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxRetryCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxRetryCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxRetryCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxDirectMaxRetryExpiryCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxDirectMaxRetryExpiryCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxIndirectMaxRetryExpiryCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxIndirectMaxRetryExpiryCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxErrCcaCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxErrCcaCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxErrCcaCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxErrAbortCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxErrAbortCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxErrAbortCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxErrBusyChannelCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxErrBusyChannelCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxErrBusyChannelCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxTotalCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxTotalCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxUnicastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxUnicastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxBroadcastCountWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxBroadcastCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxDataCountWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxDataCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxDataPollCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxDataPollCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxBeaconCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxBeaconCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxBeaconRequestCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxBeaconRequestCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxOtherCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxAddressFilteredCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxAddressFilteredCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxAddressFilteredCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxDestAddrFilteredCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxDestAddrFilteredCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxDestAddrFilteredCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxDuplicatedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxDuplicatedCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxDuplicatedCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxErrNoFrameCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxErrNoFrameCountWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxErrNoFrameCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxErrUnknownNeighborCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxErrUnknownNeighborCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxErrUnknownNeighborCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxErrInvalidSrcAddrCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxErrInvalidSrcAddrCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxErrInvalidSrcAddrCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxErrSecCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxErrSecCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxErrSecCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxErrFcsCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxErrFcsCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxErrFcsCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRxErrOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRxErrOtherCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRxErrOtherCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePendingTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePendingTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePendingTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDelayWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSecurityPolicyWithCompletion:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSecurityPolicyWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSecurityPolicyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeChannelPage0MaskWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChannelPage0MaskWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChannelPage0MaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalDatasetComponentsWithCompletion:(void (^)(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalDatasetComponentsWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalDatasetComponentsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveNetworkFaultsListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveNetworkFaultsListWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveNetworkFaultsListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterThreadNetworkDiagnostics (Deprecated)

- (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:params completion:
                                           completionHandler];
}
- (void)resetCountsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributeChannelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeRoutingRoleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRoutingRoleWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeRoutingRoleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRoutingRoleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeNetworkNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworkNameWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeNetworkNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworkNameWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                }];
}

- (void)readAttributePanIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePanIdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributePanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePanIdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeExtendedPanIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtendedPanIdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeExtendedPanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtendedPanIdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMeshLocalPrefixWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeshLocalPrefixWithCompletion:
              ^(NSData * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSData *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSData *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeMeshLocalPrefixWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeshLocalPrefixWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSData *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeOverrunCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeNeighborTableListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNeighborTableWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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 subscribeAttributeNeighborTableWithParams:subscribeParams subscriptionEstablished:subscriptionEstablishedHandler reportHandler:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeNeighborTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNeighborTableWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRouteTableListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRouteTableWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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 subscribeAttributeRouteTableWithParams:subscribeParams subscriptionEstablished:subscriptionEstablishedHandler reportHandler:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeRouteTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRouteTableWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}

- (void)readAttributePartitionIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributePartitionIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeWeightingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWeightingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeWeightingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWeightingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeDataVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDataVersionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDataVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeStableDataVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStableDataVersionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeStableDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStableDataVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeLeaderRouterIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRouterIdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeLeaderRouterIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRouterIdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeDetachedRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDetachedRoleCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeDetachedRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDetachedRoleCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeChildRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChildRoleCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeChildRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChildRoleCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeRouterRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRouterRoleCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeRouterRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRouterRoleCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeLeaderRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRoleCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeLeaderRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRoleCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttachAttemptCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttachAttemptCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributePartitionIdChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdChangeCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributePartitionIdChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdChangeCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeBetterPartitionAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBetterPartitionAttachAttemptCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                   }];
}
+ (void)readAttributeBetterPartitionAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBetterPartitionAttachAttemptCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                      }];
}

- (void)readAttributeParentChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeParentChangeCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeParentChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeParentChangeCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeTxTotalCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxTotalCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeTxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxTotalCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeTxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxUnicastCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeTxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxUnicastCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeTxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBroadcastCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeTxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBroadcastCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeTxAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckRequestedCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeTxAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckRequestedCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeTxAckedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckedCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeTxAckedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckedCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeTxNoAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxNoAckRequestedCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeTxNoAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxNoAckRequestedCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeTxDataCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeTxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeTxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataPollCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeTxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataPollCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeTxBeaconCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeTxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeTxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconRequestCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeTxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconRequestCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeTxOtherCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxOtherCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeTxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxOtherCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeTxRetryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxRetryCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeTxRetryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxRetryCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDirectMaxRetryExpiryCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeTxDirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDirectMaxRetryExpiryCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxIndirectMaxRetryExpiryCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeTxIndirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxIndirectMaxRetryExpiryCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeTxErrCcaCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCcaCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeTxErrCcaCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCcaCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeTxErrAbortCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrAbortCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeTxErrAbortCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrAbortCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeTxErrBusyChannelCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrBusyChannelCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeTxErrBusyChannelCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrBusyChannelCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeRxTotalCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxTotalCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeRxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxTotalCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeRxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxUnicastCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeRxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxUnicastCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeRxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBroadcastCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeRxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBroadcastCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeRxDataCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeRxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeRxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataPollCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeRxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataPollCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeRxBeaconCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconRequestCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeRxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconRequestCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeRxOtherCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxOtherCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeRxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxOtherCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeRxAddressFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxAddressFilteredCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeRxAddressFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxAddressFilteredCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeRxDestAddrFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDestAddrFilteredCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeRxDestAddrFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDestAddrFilteredCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeRxDuplicatedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDuplicatedCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeRxDuplicatedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDuplicatedCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeRxErrNoFrameCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrNoFrameCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeRxErrNoFrameCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrNoFrameCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeRxErrUnknownNeighborCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrUnknownNeighborCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeRxErrUnknownNeighborCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrUnknownNeighborCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeRxErrInvalidSrcAddrCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrInvalidSrcAddrCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeRxErrInvalidSrcAddrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrInvalidSrcAddrCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeRxErrSecCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrSecCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRxErrSecCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrSecCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRxErrFcsCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrFcsCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRxErrFcsCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrFcsCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRxErrOtherCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrOtherCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeRxErrOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrOtherCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeActiveTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTimestampWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeActiveTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTimestampWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributePendingTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePendingTimestampWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributePendingTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePendingTimestampWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDelayWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDelayWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeSecurityPolicyWithCompletionHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityPolicyWithCompletion:
              ^(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRThreadNetworkDiagnosticsClusterSecurityPolicy *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<MTRThreadNetworkDiagnosticsClusterSecurityPolicy *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeSecurityPolicyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityPolicyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<MTRThreadNetworkDiagnosticsClusterSecurityPolicy *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeChannelPage0MaskWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelPage0MaskWithCompletion:
              ^(NSData * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSData *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSData *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeChannelPage0MaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelPage0MaskWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSData *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeOperationalDatasetComponentsWithCompletionHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalDatasetComponentsWithCompletion:
              ^(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeOperationalDatasetComponentsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalDatasetComponentsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeActiveNetworkFaultsListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeActiveNetworkFaultsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)resetCountsWithCompletion:(MTRStatusCompletion)completion
{
    [self resetCountsWithParams:nil completion:completion];
}
- (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWiFiNetworkDiagnosticsClusterResetCountsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WiFiNetworkDiagnostics::Commands::ResetCounts::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeBSSIDWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBSSIDWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBSSIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSecurityTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSecurityTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSecurityTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWiFiVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWiFiVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWiFiVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeChannelNumberWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChannelNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChannelNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRSSIWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRSSIWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRSSIWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBeaconLostCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBeaconLostCountWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBeaconLostCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBeaconRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBeaconRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBeaconRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePacketMulticastRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePacketMulticastRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePacketMulticastRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePacketMulticastTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePacketMulticastTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePacketMulticastTxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePacketUnicastRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePacketUnicastRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePacketUnicastRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePacketUnicastTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePacketUnicastTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePacketUnicastTxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentMaxRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentMaxRateWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentMaxRateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOverrunCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterWiFiNetworkDiagnostics (Deprecated)

- (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:params completion:
                                           completionHandler];
}
- (void)resetCountsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributeBssidWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBSSIDWithCompletion:
              ^(NSData * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSData *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSData *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeBssidWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBSSIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSData *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeSecurityTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeSecurityTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeWiFiVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiFiVersionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeWiFiVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiFiVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeChannelNumberWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelNumberWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeChannelNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelNumberWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRssiWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRSSIWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                      }];
}
+ (void)readAttributeRssiWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRSSIWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}

- (void)readAttributeBeaconLostCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconLostCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeBeaconLostCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconLostCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeBeaconRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconRxCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeBeaconRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconRxCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributePacketMulticastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastRxCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributePacketMulticastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastRxCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributePacketMulticastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastTxCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributePacketMulticastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastTxCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributePacketUnicastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastRxCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributePacketUnicastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastRxCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributePacketUnicastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastTxCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributePacketUnicastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastTxCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeCurrentMaxRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentMaxRateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeCurrentMaxRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentMaxRateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeOverrunCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)resetCountsWithCompletion:(MTRStatusCompletion)completion
{
    [self resetCountsWithParams:nil completion:completion];
}
- (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTREthernetNetworkDiagnosticsClusterResetCountsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = EthernetNetworkDiagnostics::Commands::ResetCounts::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributePHYRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePHYRateWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePHYRateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFullDuplexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFullDuplexWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFullDuplexWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePacketRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePacketRxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePacketRxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePacketTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePacketTxCountWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePacketTxCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTxErrCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTxErrCountWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTxErrCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCollisionCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCollisionCountWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCollisionCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOverrunCountWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOverrunCountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCarrierDetectWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCarrierDetectWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCarrierDetectWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimeSinceResetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTimeSinceResetWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimeSinceResetWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterEthernetNetworkDiagnostics (Deprecated)

- (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:params completion:
                                           completionHandler];
}
- (void)resetCountsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributePHYRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePHYRateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributePHYRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePHYRateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeFullDuplexWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFullDuplexWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFullDuplexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFullDuplexWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributePacketRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketRxCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributePacketRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketRxCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributePacketTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketTxCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributePacketTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketTxCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeTxErrCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeTxErrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeCollisionCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCollisionCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeCollisionCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCollisionCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeOverrunCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeCarrierDetectWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCarrierDetectWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeCarrierDetectWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCarrierDetectWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeTimeSinceResetWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTimeSinceResetWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeTimeSinceResetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTimeSinceResetWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterTimeSynchronization

- (void)setUTCTimeWithParams:(MTRTimeSynchronizationClusterSetUTCTimeParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimeSynchronizationClusterSetUTCTimeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = TimeSynchronization::Commands::SetUTCTime::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setTrustedTimeSourceWithParams:(MTRTimeSynchronizationClusterSetTrustedTimeSourceParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimeSynchronizationClusterSetTrustedTimeSourceParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = TimeSynchronization::Commands::SetTrustedTimeSource::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setTimeZoneWithParams:(MTRTimeSynchronizationClusterSetTimeZoneParams *)params completion:(void (^)(MTRTimeSynchronizationClusterSetTimeZoneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRTimeSynchronizationClusterSetTimeZoneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = TimeSynchronization::Commands::SetTimeZone::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRTimeSynchronizationClusterSetTimeZoneResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setDSTOffsetWithParams:(MTRTimeSynchronizationClusterSetDSTOffsetParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimeSynchronizationClusterSetDSTOffsetParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = TimeSynchronization::Commands::SetDSTOffset::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setDefaultNTPWithParams:(MTRTimeSynchronizationClusterSetDefaultNTPParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimeSynchronizationClusterSetDefaultNTPParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = TimeSynchronization::Commands::SetDefaultNTP::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeUTCTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::UTCTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUTCTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::UTCTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUTCTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::UTCTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGranularityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::Granularity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGranularityWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::Granularity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGranularityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::Granularity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimeSourceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeSource::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTimeSourceWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::TimeSource::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimeSourceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeSource::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTrustedTimeSourceWithCompletion:(void (^)(MTRTimeSynchronizationClusterTrustedTimeSourceStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TrustedTimeSource::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTrustedTimeSourceWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(MTRTimeSynchronizationClusterTrustedTimeSourceStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::TrustedTimeSource::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTrustedTimeSourceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRTimeSynchronizationClusterTrustedTimeSourceStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TrustedTimeSource::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultNTPWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::DefaultNTP::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDefaultNTPWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::DefaultNTP::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultNTPWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::DefaultNTP::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimeZoneWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZone::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTimeZoneWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZone::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimeZoneWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZone::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDSTOffsetWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::DSTOffset::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDSTOffsetWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::DSTOffset::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDSTOffsetWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::DSTOffset::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLocalTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::LocalTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLocalTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::LocalTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLocalTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::LocalTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimeZoneDatabaseWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZoneDatabase::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTimeZoneDatabaseWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZoneDatabase::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimeZoneDatabaseWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZoneDatabase::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNTPServerAvailableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::NTPServerAvailable::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNTPServerAvailableWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::NTPServerAvailable::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNTPServerAvailableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::NTPServerAvailable::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimeZoneListMaxSizeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZoneListMaxSize::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTimeZoneListMaxSizeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZoneListMaxSize::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimeZoneListMaxSizeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::TimeZoneListMaxSize::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDSTOffsetListMaxSizeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::DSTOffsetListMaxSize::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDSTOffsetListMaxSizeWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::DSTOffsetListMaxSize::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDSTOffsetListMaxSizeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::DSTOffsetListMaxSize::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportsDNSResolveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::SupportsDNSResolve::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportsDNSResolveWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::SupportsDNSResolve::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportsDNSResolveWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::SupportsDNSResolve::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TimeSynchronization::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TimeSynchronization::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBridgedDeviceBasicInformation

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::VendorName::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::VendorName::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVendorNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::VendorName::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::VendorID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::VendorID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVendorIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::VendorID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductName::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductNameWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductName::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductName::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::NodeLabel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = BridgedDeviceBasicInformation::Attributes::NodeLabel::TypeInfo;
        TypeInfo::Type cppValue;
          cppValue = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::NodeLabel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNodeLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::NodeLabel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::HardwareVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHardwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::HardwareVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHardwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::HardwareVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::HardwareVersionString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHardwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::HardwareVersionString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHardwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::HardwareVersionString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SoftwareVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSoftwareVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SoftwareVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSoftwareVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SoftwareVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SoftwareVersionString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSoftwareVersionStringWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SoftwareVersionString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSoftwareVersionStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SoftwareVersionString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ManufacturingDate::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeManufacturingDateWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ManufacturingDate::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeManufacturingDateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ManufacturingDate::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::PartNumber::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePartNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::PartNumber::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePartNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::PartNumber::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductURL::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductURLWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductURL::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductURLWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductURL::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductLabel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductLabelWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductLabel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductLabelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductLabel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SerialNumber::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSerialNumberWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SerialNumber::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSerialNumberWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::SerialNumber::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::Reachable::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReachableWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::Reachable::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReachableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::Reachable::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::UniqueID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUniqueIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::UniqueID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUniqueIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::UniqueID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductAppearanceWithCompletion:(void (^)(MTRBridgedDeviceBasicInformationClusterProductAppearanceStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductAppearance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductAppearanceWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(MTRBridgedDeviceBasicInformationClusterProductAppearanceStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductAppearance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductAppearanceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRBridgedDeviceBasicInformationClusterProductAppearanceStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ProductAppearance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BridgedDeviceBasicInformation::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBridgedDeviceBasic
@end

@implementation MTRBaseClusterBridgedDeviceBasic (Deprecated)

- (void)readAttributeVendorNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeVendorIDWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeProductNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeNodeLabelWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSString *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeHardwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeHardwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeSoftwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeSoftwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeManufacturingDateWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePartNumberWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeProductURLWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeProductLabelWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeSerialNumberWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSString *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeReachableWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeUniqueIDWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSString *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeNumberOfPositionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfPositionsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfPositionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPositionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMultiPressMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMultiPressMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMultiPressMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterSwitch (Deprecated)

- (void)readAttributeNumberOfPositionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPositionsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeNumberOfPositionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPositionsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeCurrentPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeCurrentPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeMultiPressMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMultiPressMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMultiPressMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMultiPressMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenCommissioningWindowParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRAdministratorCommissioningClusterOpenCommissioningWindowParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = AdministratorCommissioning::Commands::OpenCommissioningWindow::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)revokeCommissioningWithCompletion:(MTRStatusCompletion)completion
{
    [self revokeCommissioningWithParams:nil completion:completion];
}
- (void)revokeCommissioningWithParams:(MTRAdministratorCommissioningClusterRevokeCommissioningParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRAdministratorCommissioningClusterRevokeCommissioningParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = AdministratorCommissioning::Commands::RevokeCommissioning::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeWindowStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWindowStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWindowStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAdminFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAdminFabricIndexWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAdminFabricIndexWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAdminVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAdminVendorIdWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAdminVendorIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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 completionHandler:completionHandler];
}

- (void)readAttributeWindowStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindowStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeWindowStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindowStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeAdminFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminFabricIndexWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeAdminFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminFabricIndexWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeAdminVendorIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminVendorIdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAdminVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminVendorIdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestationRequestParams *)params completion:(void (^)(MTROperationalCredentialsClusterAttestationResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterAttestationRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::AttestationRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalCredentialsClusterAttestationResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCertificateChainRequestParams *)params completion:(void (^)(MTROperationalCredentialsClusterCertificateChainResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterCertificateChainRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::CertificateChainRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalCredentialsClusterCertificateChainResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *)params completion:(void (^)(MTROperationalCredentialsClusterCSRResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterCSRRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::CSRRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalCredentialsClusterCSRResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterAddNOCParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::AddNOC::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalCredentialsClusterNOCResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)params completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterUpdateNOCParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::UpdateNOC::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalCredentialsClusterNOCResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabricLabelParams *)params completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterUpdateFabricLabelParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::UpdateFabricLabel::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalCredentialsClusterNOCResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricParams *)params completion:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterRemoveFabricParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::RemoveFabric::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalCredentialsClusterNOCResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAddTrustedRootCertificateParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTROperationalCredentialsClusterAddTrustedRootCertificateParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalCredentials::Commands::AddTrustedRootCertificate::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeNOCsWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNOCsWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNOCsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFabricsWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFabricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedFabricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCommissionedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCommissionedFabricsWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCommissionedFabricsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTrustedRootCertificatesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTrustedRootCertificatesWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTrustedRootCertificatesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentFabricIndexWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentFabricIndexWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOperationalCredentials (Deprecated)

- (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestationRequestParams *)params completionHandler:(void (^)(MTROperationalCredentialsClusterAttestationResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self attestationRequestWithParams:params completion:
                                                  ^(MTROperationalCredentialsClusterAttestationResponseParams * _Nullable data, NSError * _Nullable error) {
                                                      // Cast is safe because subclass does not add any selectors.
                                                      completionHandler(static_cast<MTROperationalCredentialsClusterAttestationResponseParams *>(data), error);
                                                  }];
}
- (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCertificateChainRequestParams *)params completionHandler:(void (^)(MTROperationalCredentialsClusterCertificateChainResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self certificateChainRequestWithParams:params completion:
                                                       ^(MTROperationalCredentialsClusterCertificateChainResponseParams * _Nullable data, NSError * _Nullable error) {
                                                           // Cast is safe because subclass does not add any selectors.
                                                           completionHandler(static_cast<MTROperationalCredentialsClusterCertificateChainResponseParams *>(data), error);
                                                       }];
}
- (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *)params completionHandler:(void (^)(MTROperationalCredentialsClusterCSRResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self CSRRequestWithParams:params completion:
                                          ^(MTROperationalCredentialsClusterCSRResponseParams * _Nullable data, NSError * _Nullable error) {
                                              // Cast is safe because subclass does not add any selectors.
                                              completionHandler(static_cast<MTROperationalCredentialsClusterCSRResponseParams *>(data), error);
                                          }];
}
- (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self addNOCWithParams:params completion:
                                      ^(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error) {
                                          // Cast is safe because subclass does not add any selectors.
                                          completionHandler(static_cast<MTROperationalCredentialsClusterNOCResponseParams *>(data), error);
                                      }];
}
- (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)params completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self updateNOCWithParams:params completion:
                                         ^(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error) {
                                             // Cast is safe because subclass does not add any selectors.
                                             completionHandler(static_cast<MTROperationalCredentialsClusterNOCResponseParams *>(data), error);
                                         }];
}
- (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabricLabelParams *)params completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self updateFabricLabelWithParams:params completion:
                                                 ^(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error) {
                                                     // Cast is safe because subclass does not add any selectors.
                                                     completionHandler(static_cast<MTROperationalCredentialsClusterNOCResponseParams *>(data), error);
                                                 }];
}
- (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricParams *)params completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self removeFabricWithParams:params completion:
                                            ^(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable error) {
                                                // Cast is safe because subclass does not add any selectors.
                                                completionHandler(static_cast<MTROperationalCredentialsClusterNOCResponseParams *>(data), error);
                                            }];
}
- (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:
                                                 ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                     // Cast is safe because subclass does not add any selectors.
                                                     completionHandler(static_cast<NSArray *>(value), error);
                                                 }];
}
- (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:
                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                      }];
}
+ (void)readAttributeNOCsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNOCsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                         }];
}

- (void)readAttributeFabricsWithParams:(MTRReadParams * _Nullable)params completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFabricsWithParams:params completion:
                                                    ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                        // Cast is safe because subclass does not add any selectors.
                                                        completionHandler(static_cast<NSArray *>(value), error);
                                                    }];
}
- (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:
                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFabricsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeSupportedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedFabricsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeSupportedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedFabricsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeCommissionedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCommissionedFabricsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeCommissionedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCommissionedFabricsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeTrustedRootCertificatesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTrustedRootCertificatesWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeTrustedRootCertificatesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTrustedRootCertificatesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeCurrentFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFabricIndexWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeCurrentFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFabricIndexWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRGroupKeyManagementClusterKeySetWriteParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GroupKeyManagement::Commands::KeySetWrite::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)params completion:(void (^)(MTRGroupKeyManagementClusterKeySetReadResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGroupKeyManagementClusterKeySetReadParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GroupKeyManagement::Commands::KeySetRead::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGroupKeyManagementClusterKeySetReadResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRGroupKeyManagementClusterKeySetRemoveParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GroupKeyManagement::Commands::KeySetRemove::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)keySetReadAllIndicesWithCompletion:(void (^)(MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self keySetReadAllIndicesWithParams:nil completion:completion];
}
- (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAllIndicesParams * _Nullable)params completion:(void (^)(MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRGroupKeyManagementClusterKeySetReadAllIndicesParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = GroupKeyManagement::Commands::KeySetReadAllIndices::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeGroupKeyMapWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGroupKeyMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGroupTableWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGroupTableWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGroupTableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxGroupsPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxGroupsPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxGroupsPerFabricWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxGroupKeysPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxGroupKeysPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxGroupKeysPerFabricWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
                                          ^(MTRGroupKeyManagementClusterKeySetReadResponseParams * _Nullable data, NSError * _Nullable error) {
                                              // Cast is safe because subclass does not add any selectors.
                                              completionHandler(static_cast<MTRGroupKeyManagementClusterKeySetReadResponseParams *>(data), error);
                                          }];
}
- (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self keySetRemoveWithParams:params completion:
                                            completionHandler];
}
- (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAllIndicesParams * _Nullable)params completionHandler:(void (^)(MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self keySetReadAllIndicesWithParams:params completion:
                                                    ^(MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams * _Nullable data, NSError * _Nullable error) {
                                                        // Cast is safe because subclass does not add any selectors.
                                                        completionHandler(static_cast<MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams *>(data), error);
                                                    }];
}

- (void)readAttributeGroupKeyMapWithParams:(MTRReadParams * _Nullable)params completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupKeyMapWithParams:params completion:
                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                            // Cast is safe because subclass does not add any selectors.
                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                        }];
}
- (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:
                                                                                                                             ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeGroupKeyMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupKeyMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeGroupTableWithParams:(MTRReadParams * _Nullable)params completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupTableWithParams:params completion:
                                                       ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                           // Cast is safe because subclass does not add any selectors.
                                                           completionHandler(static_cast<NSArray *>(value), error);
                                                       }];
}
- (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:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeGroupTableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupTableWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeMaxGroupsPerFabricWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupsPerFabricWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeMaxGroupsPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupsPerFabricWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeMaxGroupKeysPerFabricWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupKeysPerFabricWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeMaxGroupKeysPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupKeysPerFabricWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLabelListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLabelListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FixedLabel::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterFixedLabel (Deprecated)

- (void)readAttributeLabelListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(element_0.label);
       listHolder_0->mList[i_0].value = AsCharSpan(element_0.value);
      }
              cppValue = ListType_0(listHolder_0->mList, value.count);
            } else {
              cppValue = ListType_0();
            }
          }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLabelListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UserLabel::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterUserLabel (Deprecated)

- (void)readAttributeLabelListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeStateValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStateValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStateValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanState::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBooleanState (Deprecated)

- (void)readAttributeStateValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStateValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeStateValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStateValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterICDManagement

- (void)registerClientWithParams:(MTRICDManagementClusterRegisterClientParams *)params completion:(void (^)(MTRICDManagementClusterRegisterClientResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRICDManagementClusterRegisterClientParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = IcdManagement::Commands::RegisterClient::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRICDManagementClusterRegisterClientResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)unregisterClientWithParams:(MTRICDManagementClusterUnregisterClientParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRICDManagementClusterUnregisterClientParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = IcdManagement::Commands::UnregisterClient::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stayActiveRequestWithParams:(MTRICDManagementClusterStayActiveRequestParams *)params completion:(void (^)(MTRICDManagementClusterStayActiveResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRICDManagementClusterStayActiveRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = IcdManagement::Commands::StayActiveRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRICDManagementClusterStayActiveResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeIdleModeDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::IdleModeDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeIdleModeDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::IdleModeDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeIdleModeDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::IdleModeDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveModeDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ActiveModeDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveModeDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::ActiveModeDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveModeDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ActiveModeDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveModeThresholdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ActiveModeThreshold::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveModeThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::ActiveModeThreshold::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveModeThresholdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ActiveModeThreshold::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRegisteredClientsWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::RegisteredClients::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRegisteredClientsWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::RegisteredClients::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRegisteredClientsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::RegisteredClients::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeICDCounterWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ICDCounter::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeICDCounterWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::ICDCounter::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeICDCounterWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ICDCounter::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClientsSupportedPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ClientsSupportedPerFabric::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClientsSupportedPerFabricWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::ClientsSupportedPerFabric::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClientsSupportedPerFabricWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ClientsSupportedPerFabric::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUserActiveModeTriggerHintWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::UserActiveModeTriggerHint::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUserActiveModeTriggerHintWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::UserActiveModeTriggerHint::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUserActiveModeTriggerHintWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::UserActiveModeTriggerHint::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUserActiveModeTriggerInstructionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::UserActiveModeTriggerInstruction::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUserActiveModeTriggerInstructionWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::UserActiveModeTriggerInstruction::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUserActiveModeTriggerInstructionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::UserActiveModeTriggerInstruction::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperatingModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::OperatingMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperatingModeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::OperatingMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperatingModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::OperatingMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IcdManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IcdManagement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterTimer

- (void)setTimerWithParams:(MTRTimerClusterSetTimerParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimerClusterSetTimerParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Timer::Commands::SetTimer::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)resetTimerWithCompletion:(MTRStatusCompletion)completion
{
    [self resetTimerWithParams:nil completion:completion];
}
- (void)resetTimerWithParams:(MTRTimerClusterResetTimerParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimerClusterResetTimerParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Timer::Commands::ResetTimer::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addTimeWithParams:(MTRTimerClusterAddTimeParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimerClusterAddTimeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Timer::Commands::AddTime::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)reduceTimeWithParams:(MTRTimerClusterReduceTimeParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTimerClusterReduceTimeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Timer::Commands::ReduceTime::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSetTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::SetTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSetTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::SetTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSetTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::SetTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimeRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::TimeRemaining::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTimeRemainingWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::TimeRemaining::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimeRemainingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::TimeRemaining::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimerStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::TimerState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTimerStateWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::TimerState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimerStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::TimerState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Timer::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Timer::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOvenCavityOperationalState

- (void)pauseWithCompletion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self pauseWithParams:nil completion:completion];
}
- (void)pauseWithParams:(MTROvenCavityOperationalStateClusterPauseParams * _Nullable)params completion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROvenCavityOperationalStateClusterPauseParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OvenCavityOperationalState::Commands::Pause::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROvenCavityOperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopWithCompletion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self stopWithParams:nil completion:completion];
}
- (void)stopWithParams:(MTROvenCavityOperationalStateClusterStopParams * _Nullable)params completion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROvenCavityOperationalStateClusterStopParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OvenCavityOperationalState::Commands::Stop::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROvenCavityOperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)startWithCompletion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self startWithParams:nil completion:completion];
}
- (void)startWithParams:(MTROvenCavityOperationalStateClusterStartParams * _Nullable)params completion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROvenCavityOperationalStateClusterStartParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OvenCavityOperationalState::Commands::Start::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROvenCavityOperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)resumeWithCompletion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self resumeWithParams:nil completion:completion];
}
- (void)resumeWithParams:(MTROvenCavityOperationalStateClusterResumeParams * _Nullable)params completion:(void (^)(MTROvenCavityOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROvenCavityOperationalStateClusterResumeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OvenCavityOperationalState::Commands::Resume::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROvenCavityOperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributePhaseListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::PhaseList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhaseListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::PhaseList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhaseListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::PhaseList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPhaseWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::CurrentPhase::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPhaseWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::CurrentPhase::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPhaseWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::CurrentPhase::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCountdownTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::CountdownTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCountdownTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::CountdownTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCountdownTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::CountdownTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalStateListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalStateList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalStateListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalStateList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalStateListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalStateList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalStateWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalErrorWithCompletion:(void (^)(MTROvenCavityOperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalError::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalErrorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(MTROvenCavityOperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalError::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalErrorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTROvenCavityOperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::OperationalError::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenCavityOperationalState::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenCavityOperationalState::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOvenMode

- (void)changeToModeWithParams:(MTROvenModeClusterChangeToModeParams *)params completion:(void (^)(MTROvenModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROvenModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OvenMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROvenModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::StartUpMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = OvenMode::Attributes::StartUpMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OvenMode::Attributes::StartUpMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::StartUpMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::OnMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = OvenMode::Attributes::OnMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OvenMode::Attributes::OnMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::OnMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OvenMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OvenMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterLaundryDryerControls

- (void)readAttributeSupportedDrynessLevelsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::SupportedDrynessLevels::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedDrynessLevelsWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::SupportedDrynessLevels::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedDrynessLevelsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::SupportedDrynessLevels::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSelectedDrynessLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::SelectedDrynessLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeSelectedDrynessLevelWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSelectedDrynessLevelWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeSelectedDrynessLevelWithValue:(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 = LaundryDryerControls::Attributes::SelectedDrynessLevel::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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)subscribeAttributeSelectedDrynessLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::SelectedDrynessLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSelectedDrynessLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::SelectedDrynessLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryDryerControls::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryDryerControls::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterModeSelect

- (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRModeSelectClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ModeSelect::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDescriptionWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDescriptionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStandardNamespaceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStandardNamespaceWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStandardNamespaceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeStandardNamespaceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStandardNamespaceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeStandardNamespaceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStandardNamespaceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeSupportedModesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedModesWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeSupportedModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedModesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeCurrentModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeCurrentModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeStartUpModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeStartUpModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeOnModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeOnModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterLaundryWasherMode

- (void)changeToModeWithParams:(MTRLaundryWasherModeClusterChangeToModeParams *)params completion:(void (^)(MTRLaundryWasherModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRLaundryWasherModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LaundryWasherMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRLaundryWasherModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::StartUpMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = LaundryWasherMode::Attributes::StartUpMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LaundryWasherMode::Attributes::StartUpMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::StartUpMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::OnMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = LaundryWasherMode::Attributes::OnMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = LaundryWasherMode::Attributes::OnMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::OnMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterRefrigeratorAndTemperatureControlledCabinetMode

- (void)changeToModeWithParams:(MTRRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeParams *)params completion:(void (^)(MTRRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = RefrigeratorAndTemperatureControlledCabinetMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::StartUpMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::StartUpMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::StartUpMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::StartUpMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::OnMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::OnMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::OnMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::OnMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterLaundryWasherControls

- (void)readAttributeSpinSpeedsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::SpinSpeeds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSpinSpeedsWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::SpinSpeeds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSpinSpeedsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::SpinSpeeds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSpinSpeedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::SpinSpeedCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeSpinSpeedCurrentWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSpinSpeedCurrentWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeSpinSpeedCurrentWithValue:(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 = LaundryWasherControls::Attributes::SpinSpeedCurrent::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

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

- (void)subscribeAttributeSpinSpeedCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::SpinSpeedCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSpinSpeedCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::SpinSpeedCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfRinsesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::NumberOfRinses::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeNumberOfRinsesWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNumberOfRinsesWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeNumberOfRinsesWithValue:(NSNumber * _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 = LaundryWasherControls::Attributes::NumberOfRinses::TypeInfo;
        TypeInfo::Type cppValue;
              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

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

- (void)subscribeAttributeNumberOfRinsesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::NumberOfRinses::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfRinsesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::NumberOfRinses::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedRinsesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::SupportedRinses::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedRinsesWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::SupportedRinses::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedRinsesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::SupportedRinses::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LaundryWasherControls::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LaundryWasherControls::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterRVCRunMode

- (void)changeToModeWithParams:(MTRRVCRunModeClusterChangeToModeParams *)params completion:(void (^)(MTRRVCRunModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRRVCRunModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = RvcRunMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRRVCRunModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcRunMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcRunMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterRVCCleanMode

- (void)changeToModeWithParams:(MTRRVCCleanModeClusterChangeToModeParams *)params completion:(void (^)(MTRRVCCleanModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRRVCCleanModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = RvcCleanMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRRVCCleanModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcCleanMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcCleanMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterTemperatureControl

- (void)setTemperatureWithCompletion:(MTRStatusCompletion)completion
{
    [self setTemperatureWithParams:nil completion:completion];
}
- (void)setTemperatureWithParams:(MTRTemperatureControlClusterSetTemperatureParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRTemperatureControlClusterSetTemperatureParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = TemperatureControl::Commands::SetTemperature::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeTemperatureSetpointWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::TemperatureSetpoint::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTemperatureSetpointWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::TemperatureSetpoint::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTemperatureSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::TemperatureSetpoint::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::MinTemperature::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::MinTemperature::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::MinTemperature::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::MaxTemperature::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::MaxTemperature::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::MaxTemperature::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStepWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::Step::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStepWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::Step::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStepWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::Step::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSelectedTemperatureLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::SelectedTemperatureLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSelectedTemperatureLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::SelectedTemperatureLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSelectedTemperatureLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::SelectedTemperatureLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedTemperatureLevelsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::SupportedTemperatureLevels::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedTemperatureLevelsWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::SupportedTemperatureLevels::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedTemperatureLevelsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::SupportedTemperatureLevels::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterRefrigeratorAlarm

- (void)readAttributeMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::Mask::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaskWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::Mask::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::Mask::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::State::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStateWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::State::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::State::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::Supported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::Supported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::Supported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RefrigeratorAlarm::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RefrigeratorAlarm::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDishwasherMode

- (void)changeToModeWithParams:(MTRDishwasherModeClusterChangeToModeParams *)params completion:(void (^)(MTRDishwasherModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDishwasherModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DishwasherMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDishwasherModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::StartUpMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = DishwasherMode::Attributes::StartUpMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DishwasherMode::Attributes::StartUpMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::StartUpMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::OnMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = DishwasherMode::Attributes::OnMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DishwasherMode::Attributes::OnMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::OnMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterAirQuality

- (void)readAttributeAirQualityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::AirQuality::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAirQualityWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AirQuality::Attributes::AirQuality::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAirQualityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::AirQuality::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AirQuality::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AirQuality::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AirQuality::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AirQuality::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AirQuality::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AirQuality::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AirQuality::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterSmokeCOAlarm

- (void)selfTestRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self selfTestRequestWithParams:nil completion:completion];
}
- (void)selfTestRequestWithParams:(MTRSmokeCOAlarmClusterSelfTestRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRSmokeCOAlarmClusterSelfTestRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = SmokeCoAlarm::Commands::SelfTestRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeExpressedStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ExpressedState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeExpressedStateWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::ExpressedState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeExpressedStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ExpressedState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSmokeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::SmokeState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSmokeStateWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::SmokeState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSmokeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::SmokeState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCOStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::COState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCOStateWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::COState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCOStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::COState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatteryAlertWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::BatteryAlert::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatteryAlertWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::BatteryAlert::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatteryAlertWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::BatteryAlert::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDeviceMutedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::DeviceMuted::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDeviceMutedWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::DeviceMuted::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDeviceMutedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::DeviceMuted::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTestInProgressWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::TestInProgress::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTestInProgressWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::TestInProgress::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTestInProgressWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::TestInProgress::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHardwareFaultAlertWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::HardwareFaultAlert::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHardwareFaultAlertWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::HardwareFaultAlert::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHardwareFaultAlertWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::HardwareFaultAlert::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEndOfServiceAlertWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::EndOfServiceAlert::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEndOfServiceAlertWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::EndOfServiceAlert::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEndOfServiceAlertWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::EndOfServiceAlert::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInterconnectSmokeAlarmWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::InterconnectSmokeAlarm::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInterconnectSmokeAlarmWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::InterconnectSmokeAlarm::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInterconnectSmokeAlarmWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::InterconnectSmokeAlarm::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInterconnectCOAlarmWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::InterconnectCOAlarm::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInterconnectCOAlarmWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::InterconnectCOAlarm::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInterconnectCOAlarmWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::InterconnectCOAlarm::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeContaminationStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ContaminationState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeContaminationStateWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::ContaminationState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeContaminationStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ContaminationState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSmokeSensitivityLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::SmokeSensitivityLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeSmokeSensitivityLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSmokeSensitivityLevelWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeSmokeSensitivityLevelWithValue:(NSNumber * _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 = SmokeCoAlarm::Attributes::SmokeSensitivityLevel::TypeInfo;
        TypeInfo::Type cppValue;
              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

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

- (void)subscribeAttributeSmokeSensitivityLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::SmokeSensitivityLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSmokeSensitivityLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::SmokeSensitivityLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeExpiryDateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ExpiryDate::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeExpiryDateWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::ExpiryDate::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeExpiryDateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ExpiryDate::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SmokeCoAlarm::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SmokeCoAlarm::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDishwasherAlarm

- (void)resetWithParams:(MTRDishwasherAlarmClusterResetParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDishwasherAlarmClusterResetParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DishwasherAlarm::Commands::Reset::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDishwasherAlarmClusterModifyEnabledAlarmsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DishwasherAlarm::Commands::ModifyEnabledAlarms::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::Mask::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaskWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::Mask::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::Mask::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLatchWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::Latch::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLatchWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::Latch::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLatchWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::Latch::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::State::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStateWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::State::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::State::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::Supported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::Supported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::Supported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DishwasherAlarm::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DishwasherAlarm::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterMicrowaveOvenMode

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterMicrowaveOvenControl

- (void)setCookingParametersWithCompletion:(MTRStatusCompletion)completion
{
    [self setCookingParametersWithParams:nil completion:completion];
}
- (void)setCookingParametersWithParams:(MTRMicrowaveOvenControlClusterSetCookingParametersParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMicrowaveOvenControlClusterSetCookingParametersParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MicrowaveOvenControl::Commands::SetCookingParameters::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addMoreTimeWithParams:(MTRMicrowaveOvenControlClusterAddMoreTimeParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMicrowaveOvenControlClusterAddMoreTimeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MicrowaveOvenControl::Commands::AddMoreTime::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeCookTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::CookTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCookTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::CookTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCookTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::CookTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxCookTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MaxCookTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxCookTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MaxCookTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxCookTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MaxCookTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::PowerSetting::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerSettingWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::PowerSetting::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::PowerSetting::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MinPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MinPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MinPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MaxPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MaxPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::MaxPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerStepWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::PowerStep::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerStepWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::PowerStep::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerStepWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::PowerStep::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedWattsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::SupportedWatts::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedWattsWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::SupportedWatts::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedWattsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::SupportedWatts::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSelectedWattIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::SelectedWattIndex::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSelectedWattIndexWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::SelectedWattIndex::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSelectedWattIndexWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::SelectedWattIndex::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWattRatingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::WattRating::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWattRatingWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::WattRating::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWattRatingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::WattRating::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MicrowaveOvenControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MicrowaveOvenControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOperationalState

- (void)pauseWithCompletion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self pauseWithParams:nil completion:completion];
}
- (void)pauseWithParams:(MTROperationalStateClusterPauseParams * _Nullable)params completion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalStateClusterPauseParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalState::Commands::Pause::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopWithCompletion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self stopWithParams:nil completion:completion];
}
- (void)stopWithParams:(MTROperationalStateClusterStopParams * _Nullable)params completion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalStateClusterStopParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalState::Commands::Stop::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)startWithCompletion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self startWithParams:nil completion:completion];
}
- (void)startWithParams:(MTROperationalStateClusterStartParams * _Nullable)params completion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalStateClusterStartParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalState::Commands::Start::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)resumeWithCompletion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self resumeWithParams:nil completion:completion];
}
- (void)resumeWithParams:(MTROperationalStateClusterResumeParams * _Nullable)params completion:(void (^)(MTROperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTROperationalStateClusterResumeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = OperationalState::Commands::Resume::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTROperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributePhaseListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::PhaseList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhaseListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::PhaseList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhaseListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::PhaseList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPhaseWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::CurrentPhase::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPhaseWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::CurrentPhase::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPhaseWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::CurrentPhase::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCountdownTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::CountdownTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCountdownTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::CountdownTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCountdownTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::CountdownTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalStateListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::OperationalStateList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalStateListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::OperationalStateList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalStateListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::OperationalStateList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::OperationalState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalStateWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::OperationalState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::OperationalState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalErrorWithCompletion:(void (^)(MTROperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::OperationalError::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalErrorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(MTROperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::OperationalError::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalErrorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTROperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::OperationalError::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OperationalState::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OperationalState::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterRVCOperationalState

- (void)pauseWithCompletion:(void (^)(MTRRVCOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self pauseWithParams:nil completion:completion];
}
- (void)pauseWithParams:(MTRRVCOperationalStateClusterPauseParams * _Nullable)params completion:(void (^)(MTRRVCOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRRVCOperationalStateClusterPauseParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = RvcOperationalState::Commands::Pause::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRRVCOperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)resumeWithCompletion:(void (^)(MTRRVCOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self resumeWithParams:nil completion:completion];
}
- (void)resumeWithParams:(MTRRVCOperationalStateClusterResumeParams * _Nullable)params completion:(void (^)(MTRRVCOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRRVCOperationalStateClusterResumeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = RvcOperationalState::Commands::Resume::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRRVCOperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)goHomeWithCompletion:(void (^)(MTRRVCOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self goHomeWithParams:nil completion:completion];
}
- (void)goHomeWithParams:(MTRRVCOperationalStateClusterGoHomeParams * _Nullable)params completion:(void (^)(MTRRVCOperationalStateClusterOperationalCommandResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRRVCOperationalStateClusterGoHomeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = RvcOperationalState::Commands::GoHome::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRRVCOperationalStateClusterOperationalCommandResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributePhaseListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::PhaseList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhaseListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::PhaseList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhaseListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::PhaseList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPhaseWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::CurrentPhase::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPhaseWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::CurrentPhase::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPhaseWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::CurrentPhase::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCountdownTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::CountdownTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCountdownTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::CountdownTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCountdownTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::CountdownTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalStateListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalStateList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalStateListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalStateList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalStateListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalStateList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalStateWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalErrorWithCompletion:(void (^)(MTRRVCOperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalError::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalErrorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(MTRRVCOperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalError::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalErrorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRRVCOperationalStateClusterErrorStateStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::OperationalError::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RvcOperationalState::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RvcOperationalState::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterScenesManagement

- (void)addSceneWithParams:(MTRScenesManagementClusterAddSceneParams *)params completion:(void (^)(MTRScenesManagementClusterAddSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterAddSceneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::AddScene::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRScenesManagementClusterAddSceneResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)viewSceneWithParams:(MTRScenesManagementClusterViewSceneParams *)params completion:(void (^)(MTRScenesManagementClusterViewSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterViewSceneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::ViewScene::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRScenesManagementClusterViewSceneResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)removeSceneWithParams:(MTRScenesManagementClusterRemoveSceneParams *)params completion:(void (^)(MTRScenesManagementClusterRemoveSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterRemoveSceneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::RemoveScene::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRScenesManagementClusterRemoveSceneResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)removeAllScenesWithParams:(MTRScenesManagementClusterRemoveAllScenesParams *)params completion:(void (^)(MTRScenesManagementClusterRemoveAllScenesResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterRemoveAllScenesParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::RemoveAllScenes::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRScenesManagementClusterRemoveAllScenesResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)storeSceneWithParams:(MTRScenesManagementClusterStoreSceneParams *)params completion:(void (^)(MTRScenesManagementClusterStoreSceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterStoreSceneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::StoreScene::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRScenesManagementClusterStoreSceneResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)recallSceneWithParams:(MTRScenesManagementClusterRecallSceneParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterRecallSceneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::RecallScene::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getSceneMembershipWithParams:(MTRScenesManagementClusterGetSceneMembershipParams *)params completion:(void (^)(MTRScenesManagementClusterGetSceneMembershipResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterGetSceneMembershipParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::GetSceneMembership::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRScenesManagementClusterGetSceneMembershipResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)copySceneWithParams:(MTRScenesManagementClusterCopySceneParams *)params completion:(void (^)(MTRScenesManagementClusterCopySceneResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRScenesManagementClusterCopySceneParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ScenesManagement::Commands::CopyScene::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRScenesManagementClusterCopySceneResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeLastConfiguredByWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::LastConfiguredBy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLastConfiguredByWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::LastConfiguredBy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLastConfiguredByWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::LastConfiguredBy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSceneTableSizeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::SceneTableSize::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSceneTableSizeWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::SceneTableSize::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSceneTableSizeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::SceneTableSize::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFabricSceneInfoWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::FabricSceneInfo::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFabricSceneInfoWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::FabricSceneInfo::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFabricSceneInfoWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::FabricSceneInfo::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ScenesManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ScenesManagement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterHEPAFilterMonitoring

- (void)resetConditionWithCompletion:(MTRStatusCompletion)completion
{
    [self resetConditionWithParams:nil completion:completion];
}
- (void)resetConditionWithParams:(MTRHEPAFilterMonitoringClusterResetConditionParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRHEPAFilterMonitoringClusterResetConditionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = HepaFilterMonitoring::Commands::ResetCondition::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeConditionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::Condition::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeConditionWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::Condition::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeConditionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::Condition::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDegradationDirectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::DegradationDirection::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDegradationDirectionWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::DegradationDirection::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDegradationDirectionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::DegradationDirection::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeChangeIndicationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ChangeIndication::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChangeIndicationWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ChangeIndication::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChangeIndicationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ChangeIndication::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInPlaceIndicatorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::InPlaceIndicator::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInPlaceIndicatorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::InPlaceIndicator::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInPlaceIndicatorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::InPlaceIndicator::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLastChangedTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeLastChangedTimeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLastChangedTimeWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeLastChangedTimeWithValue:(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 = HepaFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedIntValue;
  }

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

- (void)subscribeAttributeLastChangedTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLastChangedTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReplacementProductListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ReplacementProductList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReplacementProductListWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ReplacementProductList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReplacementProductListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ReplacementProductList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = HepaFilterMonitoring::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterActivatedCarbonFilterMonitoring

- (void)resetConditionWithCompletion:(MTRStatusCompletion)completion
{
    [self resetConditionWithParams:nil completion:completion];
}
- (void)resetConditionWithParams:(MTRActivatedCarbonFilterMonitoringClusterResetConditionParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRActivatedCarbonFilterMonitoringClusterResetConditionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ActivatedCarbonFilterMonitoring::Commands::ResetCondition::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeConditionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::Condition::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeConditionWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::Condition::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeConditionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::Condition::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDegradationDirectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::DegradationDirection::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDegradationDirectionWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::DegradationDirection::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDegradationDirectionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::DegradationDirection::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeChangeIndicationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ChangeIndication::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChangeIndicationWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ChangeIndication::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChangeIndicationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ChangeIndication::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInPlaceIndicatorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::InPlaceIndicator::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInPlaceIndicatorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::InPlaceIndicator::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInPlaceIndicatorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::InPlaceIndicator::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLastChangedTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeLastChangedTimeWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeLastChangedTimeWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeLastChangedTimeWithValue:(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 = ActivatedCarbonFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedIntValue;
  }

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

- (void)subscribeAttributeLastChangedTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLastChangedTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReplacementProductListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ReplacementProductList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReplacementProductListWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ReplacementProductList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReplacementProductListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ReplacementProductList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBooleanStateConfiguration

- (void)suppressAlarmWithParams:(MTRBooleanStateConfigurationClusterSuppressAlarmParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRBooleanStateConfigurationClusterSuppressAlarmParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = BooleanStateConfiguration::Commands::SuppressAlarm::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enableDisableAlarmWithParams:(MTRBooleanStateConfigurationClusterEnableDisableAlarmParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRBooleanStateConfigurationClusterEnableDisableAlarmParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = BooleanStateConfiguration::Commands::EnableDisableAlarm::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeCurrentSensitivityLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::CurrentSensitivityLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeCurrentSensitivityLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeCurrentSensitivityLevelWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeCurrentSensitivityLevelWithValue:(NSNumber * _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 = BooleanStateConfiguration::Attributes::CurrentSensitivityLevel::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

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

- (void)subscribeAttributeCurrentSensitivityLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::CurrentSensitivityLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentSensitivityLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::CurrentSensitivityLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedSensitivityLevelsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::SupportedSensitivityLevels::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedSensitivityLevelsWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::SupportedSensitivityLevels::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedSensitivityLevelsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::SupportedSensitivityLevels::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultSensitivityLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::DefaultSensitivityLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDefaultSensitivityLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::DefaultSensitivityLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultSensitivityLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::DefaultSensitivityLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAlarmsActiveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsActive::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAlarmsActiveWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsActive::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAlarmsActiveWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsActive::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAlarmsSuppressedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsSuppressed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAlarmsSuppressedWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsSuppressed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAlarmsSuppressedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsSuppressed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAlarmsEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsEnabled::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAlarmsEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsEnabled::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAlarmsEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsEnabled::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAlarmsSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsSupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAlarmsSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsSupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAlarmsSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AlarmsSupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSensorFaultWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::SensorFault::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSensorFaultWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::SensorFault::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSensorFaultWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::SensorFault::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BooleanStateConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BooleanStateConfiguration::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterValveConfigurationAndControl

- (void)openWithCompletion:(MTRStatusCompletion)completion
{
    [self openWithParams:nil completion:completion];
}
- (void)openWithParams:(MTRValveConfigurationAndControlClusterOpenParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRValveConfigurationAndControlClusterOpenParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ValveConfigurationAndControl::Commands::Open::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)closeWithCompletion:(MTRStatusCompletion)completion
{
    [self closeWithParams:nil completion:completion];
}
- (void)closeWithParams:(MTRValveConfigurationAndControlClusterCloseParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRValveConfigurationAndControlClusterCloseParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ValveConfigurationAndControl::Commands::Close::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeOpenDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOpenDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOpenDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultOpenDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::DefaultOpenDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeDefaultOpenDurationWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDefaultOpenDurationWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeDefaultOpenDurationWithValue:(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 = ValveConfigurationAndControl::Attributes::DefaultOpenDuration::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedIntValue;
  }

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

- (void)subscribeAttributeDefaultOpenDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::DefaultOpenDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultOpenDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::DefaultOpenDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAutoCloseTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AutoCloseTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAutoCloseTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AutoCloseTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAutoCloseTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AutoCloseTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRemainingDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::RemainingDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRemainingDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::RemainingDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRemainingDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::RemainingDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentStateWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTargetStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::TargetState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTargetStateWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::TargetState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTargetStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::TargetState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTargetLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::TargetLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTargetLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::TargetLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTargetLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::TargetLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultOpenLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::DefaultOpenLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeDefaultOpenLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDefaultOpenLevelWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeDefaultOpenLevelWithValue:(NSNumber * _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 = ValveConfigurationAndControl::Attributes::DefaultOpenLevel::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

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

- (void)subscribeAttributeDefaultOpenLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::DefaultOpenLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultOpenLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::DefaultOpenLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeValveFaultWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::ValveFault::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeValveFaultWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::ValveFault::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeValveFaultWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::ValveFault::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelStepWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::LevelStep::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelStepWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::LevelStep::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelStepWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::LevelStep::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ValveConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterElectricalPowerMeasurement

- (void)readAttributePowerModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::PowerMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerModeWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::PowerMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::PowerMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfMeasurementTypesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::NumberOfMeasurementTypes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfMeasurementTypesWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::NumberOfMeasurementTypes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfMeasurementTypesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::NumberOfMeasurementTypes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAccuracyWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Accuracy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAccuracyWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Accuracy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAccuracyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Accuracy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRangesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Ranges::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRangesWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Ranges::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRangesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Ranges::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Voltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Voltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Voltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ActiveCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ActiveCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ActiveCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReactiveCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ReactiveCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReactiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ReactiveCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReactiveCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ReactiveCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApparentCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ApparentCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApparentCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ApparentCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApparentCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ApparentCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ActivePower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ActivePower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ActivePower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ReactivePower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReactivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ReactivePower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReactivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ReactivePower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ApparentPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApparentPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ApparentPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApparentPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ApparentPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRMSVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRMSVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRMSVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRMSCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRMSCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRMSCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRMSPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRMSPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRMSPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::RMSPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Frequency::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Frequency::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::Frequency::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHarmonicCurrentsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::HarmonicCurrents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHarmonicCurrentsWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::HarmonicCurrents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHarmonicCurrentsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::HarmonicCurrents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHarmonicPhasesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::HarmonicPhases::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHarmonicPhasesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::HarmonicPhases::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHarmonicPhasesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::HarmonicPhases::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerFactorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::PowerFactor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerFactorWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::PowerFactor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerFactorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::PowerFactor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNeutralCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::NeutralCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNeutralCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::NeutralCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNeutralCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::NeutralCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalPowerMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterElectricalEnergyMeasurement

- (void)readAttributeAccuracyWithCompletion:(void (^)(MTRElectricalEnergyMeasurementClusterMeasurementAccuracyStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::Accuracy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAccuracyWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(MTRElectricalEnergyMeasurementClusterMeasurementAccuracyStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::Accuracy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAccuracyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRElectricalEnergyMeasurementClusterMeasurementAccuracyStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::Accuracy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCumulativeEnergyImportedWithCompletion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyImported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCumulativeEnergyImportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyImported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCumulativeEnergyImportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyImported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCumulativeEnergyExportedWithCompletion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyExported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCumulativeEnergyExportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyExported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCumulativeEnergyExportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyExported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeriodicEnergyImportedWithCompletion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::PeriodicEnergyImported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeriodicEnergyImportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::PeriodicEnergyImported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeriodicEnergyImportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::PeriodicEnergyImported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeriodicEnergyExportedWithCompletion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::PeriodicEnergyExported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeriodicEnergyExportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::PeriodicEnergyExported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeriodicEnergyExportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRElectricalEnergyMeasurementClusterEnergyMeasurementStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::PeriodicEnergyExported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCumulativeEnergyResetWithCompletion:(void (^)(MTRElectricalEnergyMeasurementClusterCumulativeEnergyResetStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyReset::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCumulativeEnergyResetWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(MTRElectricalEnergyMeasurementClusterCumulativeEnergyResetStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyReset::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCumulativeEnergyResetWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRElectricalEnergyMeasurementClusterCumulativeEnergyResetStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::CumulativeEnergyReset::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalEnergyMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDemandResponseLoadControl

- (void)registerLoadControlProgramRequestWithParams:(MTRDemandResponseLoadControlClusterRegisterLoadControlProgramRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDemandResponseLoadControlClusterRegisterLoadControlProgramRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DemandResponseLoadControl::Commands::RegisterLoadControlProgramRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)unregisterLoadControlProgramRequestWithParams:(MTRDemandResponseLoadControlClusterUnregisterLoadControlProgramRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDemandResponseLoadControlClusterUnregisterLoadControlProgramRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DemandResponseLoadControl::Commands::UnregisterLoadControlProgramRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addLoadControlEventRequestWithParams:(MTRDemandResponseLoadControlClusterAddLoadControlEventRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDemandResponseLoadControlClusterAddLoadControlEventRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DemandResponseLoadControl::Commands::AddLoadControlEventRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)removeLoadControlEventRequestWithParams:(MTRDemandResponseLoadControlClusterRemoveLoadControlEventRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDemandResponseLoadControlClusterRemoveLoadControlEventRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DemandResponseLoadControl::Commands::RemoveLoadControlEventRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearLoadControlEventsRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self clearLoadControlEventsRequestWithParams:nil completion:completion];
}
- (void)clearLoadControlEventsRequestWithParams:(MTRDemandResponseLoadControlClusterClearLoadControlEventsRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDemandResponseLoadControlClusterClearLoadControlEventsRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DemandResponseLoadControl::Commands::ClearLoadControlEventsRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeLoadControlProgramsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::LoadControlPrograms::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLoadControlProgramsWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::LoadControlPrograms::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLoadControlProgramsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::LoadControlPrograms::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfLoadControlProgramsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfLoadControlPrograms::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfLoadControlProgramsWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfLoadControlPrograms::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfLoadControlProgramsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfLoadControlPrograms::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::Events::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::Events::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::Events::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveEventsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::ActiveEvents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveEventsWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::ActiveEvents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::ActiveEvents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfEventsPerProgramWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfEventsPerProgram::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfEventsPerProgramWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfEventsPerProgram::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfEventsPerProgramWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfEventsPerProgram::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfTransitionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfTransitions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfTransitions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfTransitionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::NumberOfTransitions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultRandomStartWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::DefaultRandomStart::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeDefaultRandomStartWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDefaultRandomStartWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeDefaultRandomStartWithValue:(NSNumber * _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 = DemandResponseLoadControl::Attributes::DefaultRandomStart::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

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

- (void)subscribeAttributeDefaultRandomStartWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::DefaultRandomStart::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultRandomStartWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::DefaultRandomStart::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultRandomDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::DefaultRandomDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeDefaultRandomDurationWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeDefaultRandomDurationWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeDefaultRandomDurationWithValue:(NSNumber * _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 = DemandResponseLoadControl::Attributes::DefaultRandomDuration::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

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

- (void)subscribeAttributeDefaultRandomDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::DefaultRandomDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultRandomDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::DefaultRandomDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DemandResponseLoadControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DemandResponseLoadControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterMessages

- (void)presentMessagesRequestWithParams:(MTRMessagesClusterPresentMessagesRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMessagesClusterPresentMessagesRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Messages::Commands::PresentMessagesRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)cancelMessagesRequestWithParams:(MTRMessagesClusterCancelMessagesRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMessagesClusterCancelMessagesRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Messages::Commands::CancelMessagesRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeMessagesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::Messages::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMessagesWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::Messages::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMessagesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::Messages::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveMessageIDsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::ActiveMessageIDs::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveMessageIDsWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::ActiveMessageIDs::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveMessageIDsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::ActiveMessageIDs::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Messages::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Messages::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDeviceEnergyManagement

- (void)powerAdjustRequestWithParams:(MTRDeviceEnergyManagementClusterPowerAdjustRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterPowerAdjustRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::PowerAdjustRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)cancelPowerAdjustRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self cancelPowerAdjustRequestWithParams:nil completion:completion];
}
- (void)cancelPowerAdjustRequestWithParams:(MTRDeviceEnergyManagementClusterCancelPowerAdjustRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterCancelPowerAdjustRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::CancelPowerAdjustRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)startTimeAdjustRequestWithParams:(MTRDeviceEnergyManagementClusterStartTimeAdjustRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterStartTimeAdjustRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::StartTimeAdjustRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)pauseRequestWithParams:(MTRDeviceEnergyManagementClusterPauseRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterPauseRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::PauseRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)resumeRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self resumeRequestWithParams:nil completion:completion];
}
- (void)resumeRequestWithParams:(MTRDeviceEnergyManagementClusterResumeRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterResumeRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::ResumeRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)modifyForecastRequestWithParams:(MTRDeviceEnergyManagementClusterModifyForecastRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterModifyForecastRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::ModifyForecastRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)requestConstraintBasedForecastWithParams:(MTRDeviceEnergyManagementClusterRequestConstraintBasedForecastParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterRequestConstraintBasedForecastParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::RequestConstraintBasedForecast::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)cancelRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self cancelRequestWithParams:nil completion:completion];
}
- (void)cancelRequestWithParams:(MTRDeviceEnergyManagementClusterCancelRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementClusterCancelRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagement::Commands::CancelRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeESATypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESAType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeESATypeWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESAType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeESATypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESAType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeESACanGenerateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESACanGenerate::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeESACanGenerateWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESACanGenerate::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeESACanGenerateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESACanGenerate::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeESAStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESAState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeESAStateWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESAState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeESAStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ESAState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAbsMinPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AbsMinPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAbsMinPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AbsMinPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAbsMinPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AbsMinPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAbsMaxPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AbsMaxPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAbsMaxPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AbsMaxPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAbsMaxPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AbsMaxPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerAdjustmentCapabilityWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::PowerAdjustmentCapability::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerAdjustmentCapabilityWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::PowerAdjustmentCapability::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerAdjustmentCapabilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::PowerAdjustmentCapability::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeForecastWithCompletion:(void (^)(MTRDeviceEnergyManagementClusterForecastStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::Forecast::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeForecastWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(MTRDeviceEnergyManagementClusterForecastStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::Forecast::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeForecastWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRDeviceEnergyManagementClusterForecastStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::Forecast::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOptOutStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::OptOutState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOptOutStateWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::OptOutState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOptOutStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::OptOutState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterEnergyEVSE

- (void)disableWithCompletion:(MTRStatusCompletion)completion
{
    [self disableWithParams:nil completion:completion];
}
- (void)disableWithParams:(MTREnergyEVSEClusterDisableParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEClusterDisableParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = EnergyEvse::Commands::Disable::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enableChargingWithParams:(MTREnergyEVSEClusterEnableChargingParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEClusterEnableChargingParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = EnergyEvse::Commands::EnableCharging::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enableDischargingWithParams:(MTREnergyEVSEClusterEnableDischargingParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEClusterEnableDischargingParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = EnergyEvse::Commands::EnableDischarging::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)startDiagnosticsWithCompletion:(MTRStatusCompletion)completion
{
    [self startDiagnosticsWithParams:nil completion:completion];
}
- (void)startDiagnosticsWithParams:(MTREnergyEVSEClusterStartDiagnosticsParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEClusterStartDiagnosticsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = EnergyEvse::Commands::StartDiagnostics::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setTargetsWithParams:(MTREnergyEVSEClusterSetTargetsParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEClusterSetTargetsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = EnergyEvse::Commands::SetTargets::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getTargetsWithCompletion:(void (^)(MTREnergyEVSEClusterGetTargetsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self getTargetsWithParams:nil completion:completion];
}
- (void)getTargetsWithParams:(MTREnergyEVSEClusterGetTargetsParams * _Nullable)params completion:(void (^)(MTREnergyEVSEClusterGetTargetsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEClusterGetTargetsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = EnergyEvse::Commands::GetTargets::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTREnergyEVSEClusterGetTargetsResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearTargetsWithCompletion:(MTRStatusCompletion)completion
{
    [self clearTargetsWithParams:nil completion:completion];
}
- (void)clearTargetsWithParams:(MTREnergyEVSEClusterClearTargetsParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEClusterClearTargetsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = EnergyEvse::Commands::ClearTargets::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::State::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStateWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::State::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::State::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupplyStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SupplyState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupplyStateWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::SupplyState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupplyStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SupplyState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFaultStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::FaultState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFaultStateWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::FaultState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFaultStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::FaultState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeChargingEnabledUntilWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::ChargingEnabledUntil::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChargingEnabledUntilWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::ChargingEnabledUntil::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChargingEnabledUntilWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::ChargingEnabledUntil::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDischargingEnabledUntilWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::DischargingEnabledUntil::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDischargingEnabledUntilWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::DischargingEnabledUntil::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDischargingEnabledUntilWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::DischargingEnabledUntil::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCircuitCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::CircuitCapacity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCircuitCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::CircuitCapacity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCircuitCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::CircuitCapacity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinimumChargeCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::MinimumChargeCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinimumChargeCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::MinimumChargeCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinimumChargeCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::MinimumChargeCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaximumChargeCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::MaximumChargeCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaximumChargeCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::MaximumChargeCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaximumChargeCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::MaximumChargeCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaximumDischargeCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::MaximumDischargeCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaximumDischargeCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::MaximumDischargeCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaximumDischargeCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::MaximumDischargeCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUserMaximumChargeCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::UserMaximumChargeCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeUserMaximumChargeCurrentWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeUserMaximumChargeCurrentWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeUserMaximumChargeCurrentWithValue:(NSNumber * _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 = EnergyEvse::Attributes::UserMaximumChargeCurrent::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.longLongValue;

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

- (void)subscribeAttributeUserMaximumChargeCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::UserMaximumChargeCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUserMaximumChargeCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::UserMaximumChargeCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRandomizationDelayWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::RandomizationDelayWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeRandomizationDelayWindowWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeRandomizationDelayWindowWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeRandomizationDelayWindowWithValue:(NSNumber * _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 = EnergyEvse::Attributes::RandomizationDelayWindow::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedIntValue;

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

- (void)subscribeAttributeRandomizationDelayWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::RandomizationDelayWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRandomizationDelayWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::RandomizationDelayWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNextChargeStartTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeStartTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNextChargeStartTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeStartTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNextChargeStartTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeStartTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNextChargeTargetTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeTargetTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNextChargeTargetTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeTargetTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNextChargeTargetTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeTargetTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNextChargeRequiredEnergyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeRequiredEnergy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNextChargeRequiredEnergyWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeRequiredEnergy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNextChargeRequiredEnergyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeRequiredEnergy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNextChargeTargetSoCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeTargetSoC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNextChargeTargetSoCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeTargetSoC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNextChargeTargetSoCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::NextChargeTargetSoC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApproximateEVEfficiencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::ApproximateEVEfficiency::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeApproximateEVEfficiencyWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeApproximateEVEfficiencyWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeApproximateEVEfficiencyWithValue:(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 = EnergyEvse::Attributes::ApproximateEVEfficiency::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedShortValue;
  }

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

- (void)subscribeAttributeApproximateEVEfficiencyWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::ApproximateEVEfficiency::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApproximateEVEfficiencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::ApproximateEVEfficiency::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStateOfChargeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::StateOfCharge::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStateOfChargeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::StateOfCharge::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStateOfChargeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::StateOfCharge::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBatteryCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::BatteryCapacity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBatteryCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::BatteryCapacity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBatteryCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::BatteryCapacity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVehicleIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::VehicleID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVehicleIDWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::VehicleID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVehicleIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::VehicleID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSessionIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSessionIDWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::SessionID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSessionIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSessionDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSessionDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::SessionDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSessionDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSessionEnergyChargedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionEnergyCharged::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSessionEnergyChargedWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::SessionEnergyCharged::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSessionEnergyChargedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionEnergyCharged::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSessionEnergyDischargedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionEnergyDischarged::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSessionEnergyDischargedWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::SessionEnergyDischarged::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSessionEnergyDischargedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::SessionEnergyDischarged::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvse::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvse::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterEnergyPreference

- (void)readAttributeEnergyBalancesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEnergyBalancesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnergyBalancesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentEnergyBalanceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _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 = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

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

- (void)subscribeAttributeCurrentEnergyBalanceWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentEnergyBalanceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnergyPrioritiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEnergyPrioritiesWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnergyPrioritiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLowPowerModeSensitivitiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLowPowerModeSensitivitiesWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLowPowerModeSensitivitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentLowPowerModeSensitivityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _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 = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

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

- (void)subscribeAttributeCurrentLowPowerModeSensitivityWithParams:(MTRSubscribeParams * _Nonnull)params
                                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentLowPowerModeSensitivityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyPreference::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyPreference::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPowerTopology

- (void)readAttributeAvailableEndpointsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::AvailableEndpoints::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAvailableEndpointsWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::AvailableEndpoints::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAvailableEndpointsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::AvailableEndpoints::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveEndpointsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::ActiveEndpoints::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveEndpointsWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::ActiveEndpoints::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveEndpointsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::ActiveEndpoints::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PowerTopology::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PowerTopology::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterEnergyEVSEMode

- (void)changeToModeWithParams:(MTREnergyEVSEModeClusterChangeToModeParams *)params completion:(void (^)(MTREnergyEVSEModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTREnergyEVSEModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = EnergyEvseMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTREnergyEVSEModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::StartUpMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = EnergyEvseMode::Attributes::StartUpMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = EnergyEvseMode::Attributes::StartUpMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::StartUpMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::OnMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = EnergyEvseMode::Attributes::OnMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = EnergyEvseMode::Attributes::OnMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::OnMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = EnergyEvseMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = EnergyEvseMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDeviceEnergyManagementMode

- (void)changeToModeWithParams:(MTRDeviceEnergyManagementModeClusterChangeToModeParams *)params completion:(void (^)(MTRDeviceEnergyManagementModeClusterChangeToModeResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDeviceEnergyManagementModeClusterChangeToModeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DeviceEnergyManagementMode::Commands::ChangeToMode::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDeviceEnergyManagementModeClusterChangeToModeResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::SupportedModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedModesWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::SupportedModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::SupportedModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::CurrentMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentModeWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::CurrentMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::CurrentMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::StartUpMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = DeviceEnergyManagementMode::Attributes::StartUpMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::StartUpMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::StartUpMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::OnMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = DeviceEnergyManagementMode::Attributes::OnMode::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::OnMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::OnMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DeviceEnergyManagementMode::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterDoorLock

- (void)lockDoorWithCompletion:(MTRStatusCompletion)completion
{
    [self lockDoorWithParams:nil completion:completion];
}
- (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterLockDoorParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::LockDoor::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)unlockDoorWithCompletion:(MTRStatusCompletion)completion
{
    [self unlockDoorWithParams:nil completion:completion];
}
- (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterUnlockDoorParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::UnlockDoor::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterUnlockWithTimeoutParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::UnlockWithTimeout::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterSetWeekDayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::SetWeekDaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams *)params completion:(void (^)(MTRDoorLockClusterGetWeekDayScheduleResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterGetWeekDayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::GetWeekDaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDoorLockClusterGetWeekDayScheduleResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterClearWeekDayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::ClearWeekDaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterSetYearDayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::SetYearDaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams *)params completion:(void (^)(MTRDoorLockClusterGetYearDayScheduleResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterGetYearDayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::GetYearDaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDoorLockClusterGetYearDayScheduleResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterClearYearDayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::ClearYearDaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterSetHolidayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::SetHolidaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams *)params completion:(void (^)(MTRDoorLockClusterGetHolidayScheduleResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterGetHolidayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::GetHolidaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDoorLockClusterGetHolidayScheduleResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterClearHolidayScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::ClearHolidaySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterSetUserParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::SetUser::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params completion:(void (^)(MTRDoorLockClusterGetUserResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterGetUserParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::GetUser::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDoorLockClusterGetUserResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterClearUserParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::ClearUser::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params completion:(void (^)(MTRDoorLockClusterSetCredentialResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterSetCredentialParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::SetCredential::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDoorLockClusterSetCredentialResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusParams *)params completion:(void (^)(MTRDoorLockClusterGetCredentialStatusResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterGetCredentialStatusParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = DoorLock::Commands::GetCredentialStatus::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRDoorLockClusterGetCredentialStatusResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterClearCredentialParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::ClearCredential::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)unboltDoorWithCompletion:(MTRStatusCompletion)completion
{
    [self unboltDoorWithParams:nil completion:completion];
}
- (void)unboltDoorWithParams:(MTRDoorLockClusterUnboltDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterUnboltDoorParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::UnboltDoor::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setAliroReaderConfigWithParams:(MTRDoorLockClusterSetAliroReaderConfigParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterSetAliroReaderConfigParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::SetAliroReaderConfig::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearAliroReaderConfigWithCompletion:(MTRStatusCompletion)completion
{
    [self clearAliroReaderConfigWithParams:nil completion:completion];
}
- (void)clearAliroReaderConfigWithParams:(MTRDoorLockClusterClearAliroReaderConfigParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRDoorLockClusterClearAliroReaderConfigParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = DoorLock::Commands::ClearAliroReaderConfig::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeLockStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLockStateWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLockStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLockTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLockTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLockTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActuatorEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActuatorEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActuatorEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDoorStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDoorStateWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDoorStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDoorOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDoorOpenEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDoorClosedEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDoorClosedEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOpenPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfTotalUsersSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfTotalUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfTotalUsersSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfPINUsersSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfPINUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfPINUsersSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfRFIDUsersSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfRFIDUsersSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfRFIDUsersSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfWeekDaySchedulesSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfYearDaySchedulesSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfHolidaySchedulesSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfHolidaySchedulesSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfHolidaySchedulesSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxPINCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxPINCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinPINCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinPINCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxRFIDCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxRFIDCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinRFIDCodeLengthWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinRFIDCodeLengthWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCredentialRulesSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCredentialRulesSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCredentialRulesSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfCredentialsSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfCredentialsSupportedPerUserWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfCredentialsSupportedPerUserWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLanguageWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLanguageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLEDSettingsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLEDSettingsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAutoRelockTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAutoRelockTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSoundVolumeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSoundVolumeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperatingModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperatingModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedOperatingModesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSupportedOperatingModesWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedOperatingModesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDefaultConfigurationRegisterWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDefaultConfigurationRegisterWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDefaultConfigurationRegisterWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnableLocalProgrammingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnableLocalProgrammingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnableOneTouchLockingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnableOneTouchLockingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnableInsideStatusLEDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnableInsideStatusLEDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnablePrivacyModeButtonWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnablePrivacyModeButtonWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLocalProgrammingFeaturesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLocalProgrammingFeaturesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWrongCodeEntryLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWrongCodeEntryLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUserCodeTemporaryDisableTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUserCodeTemporaryDisableTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSendPINOverTheAirWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSendPINOverTheAirWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRequirePINforRemoteOperationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRequirePINforRemoteOperationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeExpiringUserTimeoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeExpiringUserTimeoutWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAliroReaderVerificationKeyWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroReaderVerificationKey::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAliroReaderVerificationKeyWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AliroReaderVerificationKey::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAliroReaderVerificationKeyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroReaderVerificationKey::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAliroReaderGroupIdentifierWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroReaderGroupIdentifier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAliroReaderGroupIdentifierWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AliroReaderGroupIdentifier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAliroReaderGroupIdentifierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroReaderGroupIdentifier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAliroReaderGroupSubIdentifierWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroReaderGroupSubIdentifier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAliroReaderGroupSubIdentifierWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AliroReaderGroupSubIdentifier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAliroReaderGroupSubIdentifierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroReaderGroupSubIdentifier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAliroExpeditedTransactionSupportedProtocolVersionsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroExpeditedTransactionSupportedProtocolVersions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAliroExpeditedTransactionSupportedProtocolVersionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AliroExpeditedTransactionSupportedProtocolVersions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAliroExpeditedTransactionSupportedProtocolVersionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroExpeditedTransactionSupportedProtocolVersions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAliroGroupResolvingKeyWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroGroupResolvingKey::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAliroGroupResolvingKeyWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AliroGroupResolvingKey::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAliroGroupResolvingKeyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroGroupResolvingKey::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAliroSupportedBLEUWBProtocolVersionsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroSupportedBLEUWBProtocolVersions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAliroSupportedBLEUWBProtocolVersionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AliroSupportedBLEUWBProtocolVersions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAliroSupportedBLEUWBProtocolVersionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroSupportedBLEUWBProtocolVersions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAliroBLEAdvertisingVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroBLEAdvertisingVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAliroBLEAdvertisingVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AliroBLEAdvertisingVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAliroBLEAdvertisingVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AliroBLEAdvertisingVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfAliroCredentialIssuerKeysSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfAliroCredentialIssuerKeysSupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfAliroCredentialIssuerKeysSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfAliroCredentialIssuerKeysSupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfAliroCredentialIssuerKeysSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfAliroCredentialIssuerKeysSupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfAliroEndpointKeysSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfAliroEndpointKeysSupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfAliroEndpointKeysSupportedWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::NumberOfAliroEndpointKeysSupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfAliroEndpointKeysSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::NumberOfAliroEndpointKeysSupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
                                                  ^(MTRDoorLockClusterGetWeekDayScheduleResponseParams * _Nullable data, NSError * _Nullable error) {
                                                      // Cast is safe because subclass does not add any selectors.
                                                      completionHandler(static_cast<MTRDoorLockClusterGetWeekDayScheduleResponseParams *>(data), error);
                                                  }];
}
- (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:
                                                  ^(MTRDoorLockClusterGetYearDayScheduleResponseParams * _Nullable data, NSError * _Nullable error) {
                                                      // Cast is safe because subclass does not add any selectors.
                                                      completionHandler(static_cast<MTRDoorLockClusterGetYearDayScheduleResponseParams *>(data), error);
                                                  }];
}
- (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:
                                                  ^(MTRDoorLockClusterGetHolidayScheduleResponseParams * _Nullable data, NSError * _Nullable error) {
                                                      // Cast is safe because subclass does not add any selectors.
                                                      completionHandler(static_cast<MTRDoorLockClusterGetHolidayScheduleResponseParams *>(data), error);
                                                  }];
}
- (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:
                                       ^(MTRDoorLockClusterGetUserResponseParams * _Nullable data, NSError * _Nullable error) {
                                           // Cast is safe because subclass does not add any selectors.
                                           completionHandler(static_cast<MTRDoorLockClusterGetUserResponseParams *>(data), error);
                                       }];
}
- (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:
                                             ^(MTRDoorLockClusterSetCredentialResponseParams * _Nullable data, NSError * _Nullable error) {
                                                 // Cast is safe because subclass does not add any selectors.
                                                 completionHandler(static_cast<MTRDoorLockClusterSetCredentialResponseParams *>(data), error);
                                             }];
}
- (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusParams *)params completionHandler:(void (^)(MTRDoorLockClusterGetCredentialStatusResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self getCredentialStatusWithParams:params completion:
                                                   ^(MTRDoorLockClusterGetCredentialStatusResponseParams * _Nullable data, NSError * _Nullable error) {
                                                       // Cast is safe because subclass does not add any selectors.
                                                       completionHandler(static_cast<MTRDoorLockClusterGetCredentialStatusResponseParams *>(data), error);
                                                   }];
}
- (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearCredentialWithParams:params completion:
                                               completionHandler];
}

- (void)readAttributeLockStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockStateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeLockStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockStateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeLockTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeLockTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeActuatorEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActuatorEnabledWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeActuatorEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActuatorEnabledWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeDoorStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorStateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeDoorStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorStateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeDoorOpenEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorOpenEventsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeDoorOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorOpenEventsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeDoorClosedEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorClosedEventsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeDoorClosedEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorClosedEventsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeOpenPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOpenPeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOpenPeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeNumberOfTotalUsersSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfTotalUsersSupportedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeNumberOfTotalUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfTotalUsersSupportedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeNumberOfPINUsersSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPINUsersSupportedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeNumberOfPINUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPINUsersSupportedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeNumberOfRFIDUsersSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfRFIDUsersSupportedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeNumberOfRFIDUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfRFIDUsersSupportedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                          }];
}
+ (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                             }];
}

- (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                          }];
}
+ (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfYearDaySchedulesSupportedPerUserWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                             }];
}

- (void)readAttributeNumberOfHolidaySchedulesSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfHolidaySchedulesSupportedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                   }];
}
+ (void)readAttributeNumberOfHolidaySchedulesSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfHolidaySchedulesSupportedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                      }];
}

- (void)readAttributeMaxPINCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPINCodeLengthWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMaxPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPINCodeLengthWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMinPINCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinPINCodeLengthWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMinPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinPINCodeLengthWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMaxRFIDCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxRFIDCodeLengthWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeMaxRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxRFIDCodeLengthWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeMinRFIDCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinRFIDCodeLengthWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeMinRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinRFIDCodeLengthWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeCredentialRulesSupportWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCredentialRulesSupportWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeCredentialRulesSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCredentialRulesSupportWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeNumberOfCredentialsSupportedPerUserWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfCredentialsSupportedPerUserWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}
+ (void)readAttributeNumberOfCredentialsSupportedPerUserWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfCredentialsSupportedPerUserWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                        }];
}

- (void)readAttributeLanguageWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLanguageWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSString *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeLanguageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLanguageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeLEDSettingsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLEDSettingsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeLEDSettingsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLEDSettingsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeAutoRelockTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAutoRelockTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeAutoRelockTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAutoRelockTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeSoundVolumeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoundVolumeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeSoundVolumeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoundVolumeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeOperatingModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperatingModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeOperatingModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperatingModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeSupportedOperatingModesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedOperatingModesWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeSupportedOperatingModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedOperatingModesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeDefaultConfigurationRegisterWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultConfigurationRegisterWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeDefaultConfigurationRegisterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultConfigurationRegisterWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeEnableLocalProgrammingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableLocalProgrammingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeEnableLocalProgrammingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableLocalProgrammingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeEnableOneTouchLockingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableOneTouchLockingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeEnableOneTouchLockingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableOneTouchLockingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeEnableInsideStatusLEDWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableInsideStatusLEDWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeEnableInsideStatusLEDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableInsideStatusLEDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeEnablePrivacyModeButtonWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnablePrivacyModeButtonWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeEnablePrivacyModeButtonWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnablePrivacyModeButtonWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeLocalProgrammingFeaturesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalProgrammingFeaturesWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeLocalProgrammingFeaturesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalProgrammingFeaturesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeWrongCodeEntryLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWrongCodeEntryLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeWrongCodeEntryLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWrongCodeEntryLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeUserCodeTemporaryDisableTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUserCodeTemporaryDisableTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeUserCodeTemporaryDisableTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUserCodeTemporaryDisableTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeSendPINOverTheAirWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSendPINOverTheAirWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeSendPINOverTheAirWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSendPINOverTheAirWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeRequirePINforRemoteOperationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRequirePINforRemoteOperationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeRequirePINforRemoteOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRequirePINforRemoteOperationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeExpiringUserTimeoutWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExpiringUserTimeoutWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeExpiringUserTimeoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExpiringUserTimeoutWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)upOrOpenWithCompletion:(MTRStatusCompletion)completion
{
    [self upOrOpenWithParams:nil completion:completion];
}
- (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWindowCoveringClusterUpOrOpenParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WindowCovering::Commands::UpOrOpen::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)downOrCloseWithCompletion:(MTRStatusCompletion)completion
{
    [self downOrCloseWithParams:nil completion:completion];
}
- (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWindowCoveringClusterDownOrCloseParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WindowCovering::Commands::DownOrClose::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopMotionWithCompletion:(MTRStatusCompletion)completion
{
    [self stopMotionWithParams:nil completion:completion];
}
- (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWindowCoveringClusterStopMotionParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WindowCovering::Commands::StopMotion::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWindowCoveringClusterGoToLiftValueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WindowCovering::Commands::GoToLiftValue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentageParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWindowCoveringClusterGoToLiftPercentageParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WindowCovering::Commands::GoToLiftPercentage::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWindowCoveringClusterGoToTiltValueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WindowCovering::Commands::GoToTiltValue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentageParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRWindowCoveringClusterGoToTiltPercentageParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = WindowCovering::Commands::GoToTiltPercentage::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePhysicalClosedLimitLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhysicalClosedLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhysicalClosedLimitLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePhysicalClosedLimitTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhysicalClosedLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhysicalClosedLimitTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPositionLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPositionLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPositionLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPositionTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPositionTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPositionTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfActuationsLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfActuationsLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfActuationsLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfActuationsTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfActuationsTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfActuationsTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeConfigStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeConfigStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeConfigStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPositionLiftPercentageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPositionLiftPercentageWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPositionLiftPercentageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPositionTiltPercentageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPositionTiltPercentageWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPositionTiltPercentageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationalStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOperationalStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationalStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTargetPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTargetPositionLiftPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTargetPositionLiftPercent100thsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTargetPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTargetPositionTiltPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTargetPositionTiltPercent100thsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEndProductTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEndProductTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEndProductTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPositionLiftPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPositionLiftPercent100thsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentPositionTiltPercent100thsWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentPositionTiltPercent100thsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstalledOpenLimitLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstalledOpenLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstalledOpenLimitLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstalledClosedLimitLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstalledClosedLimitLiftWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstalledClosedLimitLiftWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstalledOpenLimitTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstalledOpenLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstalledOpenLimitTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstalledClosedLimitTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstalledClosedLimitTiltWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstalledClosedLimitTiltWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSafetyStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSafetyStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterWindowCovering (Deprecated)

- (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self upOrOpenWithParams:params completion:
                                        completionHandler];
}
- (void)upOrOpenWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self upOrOpenWithParams:nil completionHandler:completionHandler];
}
- (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self downOrCloseWithParams:params completion:
                                           completionHandler];
}
- (void)downOrCloseWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self downOrCloseWithParams:nil completionHandler:completionHandler];
}
- (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopMotionWithParams:params completion:
                                          completionHandler];
}
- (void)stopMotionWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopMotionWithParams:nil completionHandler: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:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                      }];
}
+ (void)readAttributeTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}

- (void)readAttributePhysicalClosedLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitLiftWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributePhysicalClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitLiftWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributePhysicalClosedLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitTiltWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributePhysicalClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitTiltWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeCurrentPositionLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeCurrentPositionLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeCurrentPositionTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeCurrentPositionTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeNumberOfActuationsLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsLiftWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeNumberOfActuationsLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsLiftWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeNumberOfActuationsTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsTiltWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeNumberOfActuationsTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsTiltWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeConfigStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeConfigStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeConfigStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeConfigStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeCurrentPositionLiftPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercentageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeCurrentPositionLiftPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercentageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeCurrentPositionTiltPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercentageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeCurrentPositionTiltPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercentageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeOperationalStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeOperationalStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeTargetPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionLiftPercent100thsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeTargetPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionLiftPercent100thsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeTargetPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionTiltPercent100thsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeTargetPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionTiltPercent100thsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeEndProductTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEndProductTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeEndProductTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEndProductTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeCurrentPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercent100thsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}
+ (void)readAttributeCurrentPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercent100thsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}

- (void)readAttributeCurrentPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercent100thsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}
+ (void)readAttributeCurrentPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercent100thsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}

- (void)readAttributeInstalledOpenLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitLiftWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeInstalledOpenLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitLiftWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeInstalledClosedLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitLiftWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeInstalledClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitLiftWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeInstalledOpenLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitTiltWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeInstalledOpenLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitTiltWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeInstalledClosedLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitTiltWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeInstalledClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitTiltWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                      }];
}
+ (void)readAttributeModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}

- (void)readAttributeSafetyStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSafetyStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSafetyStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierControlGoToPercentParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRBarrierControlClusterBarrierControlGoToPercentParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = BarrierControl::Commands::BarrierControlGoToPercent::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)barrierControlStopWithCompletion:(MTRStatusCompletion)completion
{
    [self barrierControlStopWithParams:nil completion:completion];
}
- (void)barrierControlStopWithParams:(MTRBarrierControlClusterBarrierControlStopParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRBarrierControlClusterBarrierControlStopParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = BarrierControl::Commands::BarrierControlStop::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeBarrierMovingStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBarrierMovingStateWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierMovingStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBarrierSafetyStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierSafetyStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBarrierCapabilitiesWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierCapabilitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierOpenEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierCloseEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierCloseEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierCommandOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierCommandOpenEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierCommandCloseEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierCommandCloseEventsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierOpenPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierClosePeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierClosePeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBarrierPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBarrierPositionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBarrierPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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 completionHandler:completionHandler];
}

- (void)readAttributeBarrierMovingStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierMovingStateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeBarrierMovingStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierMovingStateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeBarrierSafetyStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierSafetyStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeBarrierSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierSafetyStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeBarrierCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCapabilitiesWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeBarrierCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCapabilitiesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeBarrierOpenEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenEventsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeBarrierOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenEventsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeBarrierCloseEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCloseEventsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeBarrierCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCloseEventsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeBarrierCommandOpenEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandOpenEventsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeBarrierCommandOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandOpenEventsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeBarrierCommandCloseEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandCloseEventsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeBarrierCommandCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandCloseEventsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeBarrierOpenPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenPeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeBarrierOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenPeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeBarrierClosePeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierClosePeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeBarrierClosePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierClosePeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeBarrierPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierPositionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeBarrierPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierPositionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeMaxPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxFlowWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxFlowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinConstPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinConstPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxConstPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxConstPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinCompPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinCompPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxCompPressureWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxCompPressureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinConstSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinConstSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxConstSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxConstSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinConstFlowWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinConstFlowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxConstFlowWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxConstFlowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinConstTempWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinConstTempWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxConstTempWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxConstTempWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePumpStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePumpStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePumpStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEffectiveOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEffectiveOperationModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEffectiveOperationModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEffectiveControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEffectiveControlModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEffectiveControlModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCapacityWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLifetimeRunningHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLifetimeRunningHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLifetimeEnergyConsumedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLifetimeEnergyConsumedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOperationModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeControlModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPumpConfigurationAndControl (Deprecated)

- (void)readAttributeMaxPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPressureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeMaxPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPressureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeMaxSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxSpeedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeMaxSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxSpeedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeMaxFlowWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFlowWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeMaxFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFlowWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeMinConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstPressureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMinConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstPressureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMaxConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstPressureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMaxConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstPressureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMinCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCompPressureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeMinCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCompPressureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeMaxCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCompPressureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeMaxCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCompPressureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeMinConstSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstSpeedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMinConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstSpeedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMaxConstSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstSpeedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMaxConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstSpeedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinConstFlowWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstFlowWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeMinConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstFlowWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeMaxConstFlowWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstFlowWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeMaxConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstFlowWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeMinConstTempWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstTempWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeMinConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstTempWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeMaxConstTempWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstTempWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeMaxConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstTempWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributePumpStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePumpStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributePumpStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePumpStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeEffectiveOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveOperationModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeEffectiveOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveOperationModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeEffectiveControlModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveControlModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeEffectiveControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveControlModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeCapacityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCapacityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCapacityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeLifetimeRunningHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeRunningHoursWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeLifetimeRunningHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeRunningHoursWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeLifetimeEnergyConsumedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeEnergyConsumedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeLifetimeEnergyConsumedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeEnergyConsumedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeControlModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeControlModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeControlModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterSetpointRaiseLowerParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::SetpointRaiseLower::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterSetWeeklyScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::SetWeeklySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams *)params completion:(void (^)(MTRThermostatClusterGetWeeklyScheduleResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterGetWeeklyScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::GetWeeklySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRThermostatClusterGetWeeklyScheduleResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)clearWeeklyScheduleWithCompletion:(MTRStatusCompletion)completion
{
    [self clearWeeklyScheduleWithParams:nil completion:completion];
}
- (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklyScheduleParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterClearWeeklyScheduleParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::ClearWeeklySchedule::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setActiveScheduleRequestWithParams:(MTRThermostatClusterSetActiveScheduleRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterSetActiveScheduleRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::SetActiveScheduleRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setActivePresetRequestWithParams:(MTRThermostatClusterSetActivePresetRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterSetActivePresetRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::SetActivePresetRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)startPresetsSchedulesEditRequestWithParams:(MTRThermostatClusterStartPresetsSchedulesEditRequestParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterStartPresetsSchedulesEditRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::StartPresetsSchedulesEditRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)cancelPresetsSchedulesEditRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self cancelPresetsSchedulesEditRequestWithParams:nil completion:completion];
}
- (void)cancelPresetsSchedulesEditRequestWithParams:(MTRThermostatClusterCancelPresetsSchedulesEditRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterCancelPresetsSchedulesEditRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::CancelPresetsSchedulesEditRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)commitPresetsSchedulesRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self commitPresetsSchedulesRequestWithParams:nil completion:completion];
}
- (void)commitPresetsSchedulesRequestWithParams:(MTRThermostatClusterCommitPresetsSchedulesRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterCommitPresetsSchedulesRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::CommitPresetsSchedulesRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)cancelSetActivePresetRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self cancelSetActivePresetRequestWithParams:nil completion:completion];
}
- (void)cancelSetActivePresetRequestWithParams:(MTRThermostatClusterCancelSetActivePresetRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterCancelSetActivePresetRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::CancelSetActivePresetRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setTemperatureSetpointHoldPolicyWithParams:(MTRThermostatClusterSetTemperatureSetpointHoldPolicyParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRThermostatClusterSetTemperatureSetpointHoldPolicyParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Thermostat::Commands::SetTemperatureSetpointHoldPolicy::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeLocalTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLocalTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLocalTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOutdoorTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOutdoorTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOutdoorTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupancyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAbsMinHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAbsMinHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAbsMinHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAbsMaxHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAbsMaxHeatSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAbsMaxHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAbsMinCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAbsMinCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAbsMinCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAbsMaxCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAbsMaxCoolSetpointLimitWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAbsMaxCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePICoolingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePICoolingDemandWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePICoolingDemandWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePIHeatingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePIHeatingDemandWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePIHeatingDemandWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHVACSystemTypeConfigurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHVACSystemTypeConfigurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLocalTemperatureCalibrationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLocalTemperatureCalibrationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupiedCoolingSetpointWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupiedCoolingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupiedHeatingSetpointWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupiedHeatingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUnoccupiedCoolingSetpointWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUnoccupiedCoolingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUnoccupiedHeatingSetpointWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUnoccupiedHeatingSetpointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxHeatSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxCoolSetpointLimitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinSetpointDeadBandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinSetpointDeadBandWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRemoteSensingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRemoteSensingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeControlSequenceOfOperationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeControlSequenceOfOperationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSystemModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSystemModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeThermostatRunningModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeThermostatRunningModeWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeThermostatRunningModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartOfWeekWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStartOfWeekWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartOfWeekWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfWeeklyTransitionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfWeeklyTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfWeeklyTransitionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfDailyTransitionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfDailyTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfDailyTransitionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTemperatureSetpointHoldWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTemperatureSetpointHoldWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTemperatureSetpointHoldDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTemperatureSetpointHoldDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeThermostatProgrammingOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeThermostatProgrammingOperationModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeThermostatRunningStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeThermostatRunningStateWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeThermostatRunningStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSetpointChangeSourceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSetpointChangeSourceWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSetpointChangeSourceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSetpointChangeAmountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSetpointChangeAmountWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSetpointChangeAmountWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSetpointChangeSourceTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSetpointChangeSourceTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSetpointChangeSourceTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupiedSetbackWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOccupiedSetbackMinWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupiedSetbackMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOccupiedSetbackMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupiedSetbackMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUnoccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUnoccupiedSetbackWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUnoccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUnoccupiedSetbackMinWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUnoccupiedSetbackMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUnoccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUnoccupiedSetbackMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUnoccupiedSetbackMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEmergencyHeatDeltaWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEmergencyHeatDeltaWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACCapacityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACRefrigerantTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACRefrigerantTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACCompressorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACCompressorTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACErrorCodeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACErrorCodeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACLouverPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACLouverPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACCoilTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeACCoilTemperatureWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACCoilTemperatureWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeACCapacityformatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeACCapacityformatWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePresetTypesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PresetTypes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePresetTypesWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::PresetTypes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePresetTypesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PresetTypes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScheduleTypesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ScheduleTypes::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScheduleTypesWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::ScheduleTypes::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScheduleTypesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ScheduleTypes::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfPresetsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfPresets::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfPresetsWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::NumberOfPresets::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfPresetsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfPresets::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfSchedulesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfSchedules::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfSchedulesWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::NumberOfSchedules::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfSchedulesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfSchedules::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfScheduleTransitionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfScheduleTransitions::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfScheduleTransitionsWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::NumberOfScheduleTransitions::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfScheduleTransitionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfScheduleTransitions::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfScheduleTransitionPerDayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfScheduleTransitionPerDay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfScheduleTransitionPerDayWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::NumberOfScheduleTransitionPerDay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfScheduleTransitionPerDayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::NumberOfScheduleTransitionPerDay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePresetHandleWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ActivePresetHandle::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePresetHandleWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::ActivePresetHandle::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePresetHandleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ActivePresetHandle::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveScheduleHandleWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ActiveScheduleHandle::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveScheduleHandleWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::ActiveScheduleHandle::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveScheduleHandleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ActiveScheduleHandle::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePresetsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::Presets::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributePresetsWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributePresetsWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributePresetsWithValue:(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 = Thermostat::Attributes::Presets::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: [MTRThermostatClusterPresetStruct class]] ) {
                  // Wrong kind of value.
                  return CHIP_ERROR_INVALID_ARGUMENT;
                }
                auto element_0 = (MTRThermostatClusterPresetStruct *)value[i_0];
                       if (element_0.presetHandle == nil) {
         listHolder_0->mList[i_0].presetHandle.SetNull();
       } else {
         auto & nonNullValue_2 = listHolder_0->mList[i_0].presetHandle.SetNonNull();
           nonNullValue_2 = AsByteSpan(element_0.presetHandle);
       }
           listHolder_0->mList[i_0].presetScenario = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].presetScenario)>>(element_0.presetScenario.unsignedCharValue);
       if (element_0.name != nil) {
         auto & definedValue_2 = listHolder_0->mList[i_0].name.Emplace();
           if (element_0.name == nil) {
             definedValue_2.SetNull();
           } else {
             auto & nonNullValue_3 = definedValue_2.SetNonNull();
               nonNullValue_3 = AsCharSpan(element_0.name);
           }
       }
       if (element_0.coolingSetpoint != nil) {
         auto & definedValue_2 = listHolder_0->mList[i_0].coolingSetpoint.Emplace();
                 definedValue_2 = element_0.coolingSetpoint.shortValue;
  }
       if (element_0.heatingSetpoint != nil) {
         auto & definedValue_2 = listHolder_0->mList[i_0].heatingSetpoint.Emplace();
                 definedValue_2 = element_0.heatingSetpoint.shortValue;
  }
       if (element_0.builtIn == nil) {
         listHolder_0->mList[i_0].builtIn.SetNull();
       } else {
         auto & nonNullValue_2 = listHolder_0->mList[i_0].builtIn.SetNonNull();
                 nonNullValue_2 = element_0.builtIn.boolValue;
  }
      }
              cppValue = ListType_0(listHolder_0->mList, value.count);
            } else {
              cppValue = ListType_0();
            }
          }

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

- (void)subscribeAttributePresetsWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::Presets::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePresetsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::Presets::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSchedulesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::Schedules::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeSchedulesWithValue:(NSArray * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeSchedulesWithValue:(NSArray * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeSchedulesWithValue:(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 = Thermostat::Attributes::Schedules::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: [MTRThermostatClusterScheduleStruct class]] ) {
                  // Wrong kind of value.
                  return CHIP_ERROR_INVALID_ARGUMENT;
                }
                auto element_0 = (MTRThermostatClusterScheduleStruct *)value[i_0];
                       if (element_0.scheduleHandle == nil) {
         listHolder_0->mList[i_0].scheduleHandle.SetNull();
       } else {
         auto & nonNullValue_2 = listHolder_0->mList[i_0].scheduleHandle.SetNonNull();
           nonNullValue_2 = AsByteSpan(element_0.scheduleHandle);
       }
           listHolder_0->mList[i_0].systemMode = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].systemMode)>>(element_0.systemMode.unsignedCharValue);
       if (element_0.name != nil) {
         auto & definedValue_2 = listHolder_0->mList[i_0].name.Emplace();
           definedValue_2 = AsCharSpan(element_0.name);
       }
       if (element_0.presetHandle != nil) {
         auto & definedValue_2 = listHolder_0->mList[i_0].presetHandle.Emplace();
           definedValue_2 = AsByteSpan(element_0.presetHandle);
       }
       {
         using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].transitions)>;
         using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
         if (element_0.transitions.count != 0) {
           auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.transitions.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.transitions.count; ++i_2) {
             if ( ! [element_0.transitions[i_2] isKindOfClass: [MTRThermostatClusterScheduleTransitionStruct class]] ) {
               // Wrong kind of value.
               return CHIP_ERROR_INVALID_ARGUMENT;
             }
             auto element_2 = (MTRThermostatClusterScheduleTransitionStruct *)element_0.transitions[i_2];
                          listHolder_2->mList[i_2].dayOfWeek = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].dayOfWeek)>>(element_2.dayOfWeek.unsignedCharValue);
             listHolder_2->mList[i_2].transitionTime = element_2.transitionTime.unsignedShortValue;
       if (element_2.presetHandle != nil) {
         auto & definedValue_4 = listHolder_2->mList[i_2].presetHandle.Emplace();
           definedValue_4 = AsByteSpan(element_2.presetHandle);
       }
       if (element_2.systemMode != nil) {
         auto & definedValue_4 = listHolder_2->mList[i_2].systemMode.Emplace();
               definedValue_4 = static_cast<std::remove_reference_t<decltype(definedValue_4)>>(element_2.systemMode.unsignedCharValue);
  }
       if (element_2.coolingSetpoint != nil) {
         auto & definedValue_4 = listHolder_2->mList[i_2].coolingSetpoint.Emplace();
                 definedValue_4 = element_2.coolingSetpoint.shortValue;
  }
       if (element_2.heatingSetpoint != nil) {
         auto & definedValue_4 = listHolder_2->mList[i_2].heatingSetpoint.Emplace();
                 definedValue_4 = element_2.heatingSetpoint.shortValue;
  }
      }
           listHolder_0->mList[i_0].transitions = ListType_2(listHolder_2->mList, element_0.transitions.count);
         } else {
           listHolder_0->mList[i_0].transitions = ListType_2();
         }
       }
       if (element_0.builtIn != nil) {
         auto & definedValue_2 = listHolder_0->mList[i_0].builtIn.Emplace();
           if (element_0.builtIn == nil) {
             definedValue_2.SetNull();
           } else {
             auto & nonNullValue_3 = definedValue_2.SetNonNull();
                     nonNullValue_3 = element_0.builtIn.boolValue;
  }
       }
      }
              cppValue = ListType_0(listHolder_0->mList, value.count);
            } else {
              cppValue = ListType_0();
            }
          }

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

- (void)subscribeAttributeSchedulesWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::Schedules::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSchedulesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::Schedules::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePresetsSchedulesEditableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PresetsSchedulesEditable::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePresetsSchedulesEditableWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::PresetsSchedulesEditable::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePresetsSchedulesEditableWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::PresetsSchedulesEditable::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTemperatureSetpointHoldPolicyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldPolicy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTemperatureSetpointHoldPolicyWithParams:(MTRSubscribeParams * _Nonnull)params
                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldPolicy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTemperatureSetpointHoldPolicyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldPolicy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSetpointHoldExpiryTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointHoldExpiryTimestamp::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSetpointHoldExpiryTimestampWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::SetpointHoldExpiryTimestamp::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSetpointHoldExpiryTimestampWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::SetpointHoldExpiryTimestamp::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeQueuedPresetWithCompletion:(void (^)(MTRThermostatClusterQueuedPresetStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::QueuedPreset::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeQueuedPresetWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(MTRThermostatClusterQueuedPresetStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::QueuedPreset::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeQueuedPresetWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRThermostatClusterQueuedPresetStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::QueuedPreset::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
                                                 ^(MTRThermostatClusterGetWeeklyScheduleResponseParams * _Nullable data, NSError * _Nullable error) {
                                                     // Cast is safe because subclass does not add any selectors.
                                                     completionHandler(static_cast<MTRThermostatClusterGetWeeklyScheduleResponseParams *>(data), error);
                                                 }];
}
- (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklyScheduleParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearWeeklyScheduleWithParams:params completion:
                                                   completionHandler];
}
- (void)clearWeeklyScheduleWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearWeeklyScheduleWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributeLocalTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeLocalTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeOutdoorTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutdoorTemperatureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeOutdoorTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutdoorTemperatureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeOccupancyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeAbsMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinHeatSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeAbsMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinHeatSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeAbsMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxHeatSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeAbsMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxHeatSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeAbsMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinCoolSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeAbsMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinCoolSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeAbsMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxCoolSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeAbsMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxCoolSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributePICoolingDemandWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePICoolingDemandWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributePICoolingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePICoolingDemandWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributePIHeatingDemandWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIHeatingDemandWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributePIHeatingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIHeatingDemandWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeHVACSystemTypeConfigurationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHVACSystemTypeConfigurationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeHVACSystemTypeConfigurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHVACSystemTypeConfigurationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeLocalTemperatureCalibrationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureCalibrationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeLocalTemperatureCalibrationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureCalibrationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeOccupiedCoolingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedCoolingSetpointWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeOccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedCoolingSetpointWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeOccupiedHeatingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedHeatingSetpointWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeOccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedHeatingSetpointWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeUnoccupiedCoolingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedCoolingSetpointWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeUnoccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedCoolingSetpointWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeUnoccupiedHeatingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedHeatingSetpointWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeUnoccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedHeatingSetpointWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinHeatSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinHeatSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxHeatSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxHeatSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCoolSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCoolSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCoolSetpointLimitWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCoolSetpointLimitWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeMinSetpointDeadBandWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinSetpointDeadBandWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeMinSetpointDeadBandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinSetpointDeadBandWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRemoteSensingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemoteSensingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRemoteSensingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemoteSensingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeControlSequenceOfOperationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeControlSequenceOfOperationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeControlSequenceOfOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeControlSequenceOfOperationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeSystemModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSystemModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeSystemModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSystemModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeThermostatRunningModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeThermostatRunningModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeStartOfWeekWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartOfWeekWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeStartOfWeekWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartOfWeekWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeNumberOfWeeklyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeeklyTransitionsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeNumberOfWeeklyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeeklyTransitionsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeNumberOfDailyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfDailyTransitionsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeNumberOfDailyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfDailyTransitionsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeTemperatureSetpointHoldWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeTemperatureSetpointHoldWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeTemperatureSetpointHoldDurationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldDurationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeTemperatureSetpointHoldDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldDurationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeThermostatProgrammingOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatProgrammingOperationModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}
+ (void)readAttributeThermostatProgrammingOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatProgrammingOperationModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                       }];
}

- (void)readAttributeThermostatRunningStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningStateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeThermostatRunningStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningStateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeSetpointChangeSourceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeSetpointChangeSourceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeSetpointChangeAmountWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeAmountWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeSetpointChangeAmountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeAmountWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeSetpointChangeSourceTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceTimestampWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeSetpointChangeSourceTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceTimestampWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeOccupiedSetbackWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeOccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeOccupiedSetbackMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeOccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeOccupiedSetbackMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeOccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeUnoccupiedSetbackWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeUnoccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeUnoccupiedSetbackMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeUnoccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeUnoccupiedSetbackMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeUnoccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeEmergencyHeatDeltaWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEmergencyHeatDeltaWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeEmergencyHeatDeltaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEmergencyHeatDeltaWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeACTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeACTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeACCapacityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeACCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeACRefrigerantTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACRefrigerantTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeACRefrigerantTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACRefrigerantTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeACCompressorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCompressorTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeACCompressorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCompressorTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeACErrorCodeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACErrorCodeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeACErrorCodeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACErrorCodeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeACLouverPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACLouverPositionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeACLouverPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACLouverPositionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeACCoilTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCoilTemperatureWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeACCoilTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCoilTemperatureWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeACCapacityformatWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityformatWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeACCapacityformatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityformatWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)stepWithParams:(MTRFanControlClusterStepParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRFanControlClusterStepParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = FanControl::Commands::Step::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeFanModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFanModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFanModeSequenceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFanModeSequenceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePercentSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePercentSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePercentCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePercentCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePercentCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSpeedMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSpeedMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSpeedMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSpeedSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSpeedSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSpeedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSpeedCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSpeedCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRockSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRockSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRockSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRockSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRockSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWindSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeWindSupportWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWindSupportWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWindSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWindSettingWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAirflowDirectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::AirflowDirection::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeAirflowDirectionWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeAirflowDirectionWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeAirflowDirectionWithValue:(NSNumber * _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::AirflowDirection::TypeInfo;
        TypeInfo::Type cppValue;
              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

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

- (void)subscribeAttributeAirflowDirectionWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::AirflowDirection::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAirflowDirectionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::AirflowDirection::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterFanControl (Deprecated)

- (void)readAttributeFanModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeFanModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeFanModeSequenceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeSequenceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeFanModeSequenceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeSequenceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributePercentSettingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePercentSettingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributePercentSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePercentSettingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributePercentCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePercentCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributePercentCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePercentCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeSpeedMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeSpeedMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeSpeedSettingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedSettingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeSpeedSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedSettingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeSpeedCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeSpeedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeRockSupportWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSupportWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeRockSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSupportWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeRockSettingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSettingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeRockSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSettingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeWindSupportWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSupportWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeWindSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSupportWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeWindSettingWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSettingWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeWindSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSettingWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeTemperatureDisplayModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTemperatureDisplayModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeKeypadLockoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeKeypadLockoutWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScheduleProgrammingVisibilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScheduleProgrammingVisibilityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterThermostatUserInterfaceConfiguration (Deprecated)

- (void)readAttributeTemperatureDisplayModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureDisplayModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeTemperatureDisplayModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureDisplayModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeKeypadLockoutWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeKeypadLockoutWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeKeypadLockoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeKeypadLockoutWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeScheduleProgrammingVisibilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScheduleProgrammingVisibilityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeScheduleProgrammingVisibilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScheduleProgrammingVisibilityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveToHueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveToHue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveHueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveHue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterStepHueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::StepHue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveToSaturationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveToSaturation::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveSaturationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveSaturation::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterStepSaturationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::StepSaturation::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveToHueAndSaturationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveToHueAndSaturation::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveToColorParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveToColor::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveColorParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveColor::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterStepColorParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::StepColor::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTemperatureParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveToColorTemperatureParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveToColorTemperature::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterEnhancedMoveToHueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::EnhancedMoveToHue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterEnhancedMoveHueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::EnhancedMoveHue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterEnhancedStepHueParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::EnhancedStepHue::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhancedMoveToHueAndSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterEnhancedMoveToHueAndSaturationParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterColorLoopSetParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::ColorLoopSet::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterStopMoveStepParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::StopMoveStep::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatureParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterMoveColorTemperatureParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::MoveColorTemperature::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatureParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRColorControlClusterStepColorTemperatureParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ColorControl::Commands::StepColorTemperature::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentHueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentSaturationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentSaturationWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentSaturationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRemainingTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRemainingTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentXWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentYWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDriftCompensationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDriftCompensationWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDriftCompensationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCompensationTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCompensationTextWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCompensationTextWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorTemperatureMiredsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorTemperatureMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorTemperatureMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorModeWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOptionsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNumberOfPrimariesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNumberOfPrimariesWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNumberOfPrimariesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary1XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary1XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary1XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary1YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary1YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary1YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary1IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary1IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary1IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary2XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary2XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary2XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary2YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary2YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary2YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary2IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary2IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary2IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary3XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary3XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary3XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary3YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary3YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary3YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary3IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary3IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary3IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary4XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary4XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary4XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary4YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary4YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary4YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary4IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary4IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary4IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary5XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary5XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary5XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary5YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary5YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary5YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary5IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary5IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary5IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary6XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary6XWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary6XWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary6YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary6YWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary6YWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePrimary6IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePrimary6IntensityWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePrimary6IntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWhitePointXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWhitePointXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWhitePointYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWhitePointYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointRXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointRXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointRYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointRYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointRIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointRIntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointGXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointGXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointGYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointGYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointGIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointGIntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointBXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointBXWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointBYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointBYWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorPointBIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorPointBIntensityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnhancedCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEnhancedCurrentHueWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnhancedCurrentHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnhancedColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEnhancedColorModeWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnhancedColorModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorLoopActiveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorLoopActiveWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorLoopActiveWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorLoopDirectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorLoopDirectionWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorLoopDirectionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorLoopTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorLoopTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorLoopTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorLoopStartEnhancedHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorLoopStartEnhancedHueWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorLoopStartEnhancedHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorLoopStoredEnhancedHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorLoopStoredEnhancedHueWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorLoopStoredEnhancedHueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorCapabilitiesWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorCapabilitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorTempPhysicalMinMiredsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorTempPhysicalMinMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorTempPhysicalMinMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeColorTempPhysicalMaxMiredsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeColorTempPhysicalMaxMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeColorTempPhysicalMaxMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCoupleColorTempToLevelMinMiredsWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCoupleColorTempToLevelMinMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartUpColorTemperatureMiredsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartUpColorTemperatureMiredsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeCurrentSaturationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentSaturationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeCurrentSaturationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentSaturationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeCurrentXWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentXWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeCurrentXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentXWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeCurrentYWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentYWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeCurrentYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentYWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeDriftCompensationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDriftCompensationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeDriftCompensationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDriftCompensationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeCompensationTextWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCompensationTextWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeCompensationTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCompensationTextWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeColorTemperatureMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTemperatureMiredsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTemperatureMiredsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeColorModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeOptionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeNumberOfPrimariesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPrimariesWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeNumberOfPrimariesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPrimariesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePrimary1XWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1XWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary1XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1XWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary1YWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1YWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary1YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1YWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary1IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1IntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePrimary1IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1IntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePrimary2XWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2XWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary2XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2XWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary2YWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2YWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary2YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2YWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary2IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2IntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePrimary2IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2IntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePrimary3XWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3XWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary3XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3XWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary3YWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3YWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary3YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3YWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary3IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3IntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePrimary3IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3IntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePrimary4XWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4XWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary4XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4XWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary4YWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4YWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary4YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4YWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary4IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4IntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePrimary4IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4IntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePrimary5XWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5XWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary5XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5XWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary5YWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5YWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary5YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5YWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary5IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5IntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePrimary5IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5IntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributePrimary6XWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6XWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary6XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6XWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary6YWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6YWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributePrimary6YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6YWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributePrimary6IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6IntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePrimary6IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6IntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeWhitePointXWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointXWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeWhitePointXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointXWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeWhitePointYWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointYWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeWhitePointYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointYWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeColorPointRXWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRXWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeColorPointRXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRXWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeColorPointRYWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRYWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeColorPointRYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRYWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeColorPointRIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRIntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeColorPointRIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRIntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeColorPointGXWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGXWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeColorPointGXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGXWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeColorPointGYWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGYWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeColorPointGYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGYWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeColorPointGIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGIntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeColorPointGIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGIntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeColorPointBXWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBXWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeColorPointBXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBXWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeColorPointBYWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBYWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeColorPointBYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBYWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeColorPointBIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBIntensityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeColorPointBIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBIntensityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeEnhancedCurrentHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedCurrentHueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeEnhancedCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedCurrentHueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeEnhancedColorModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedColorModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeEnhancedColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedColorModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeColorLoopActiveWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopActiveWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeColorLoopActiveWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopActiveWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeColorLoopDirectionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopDirectionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeColorLoopDirectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopDirectionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeColorLoopTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeColorLoopTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeColorLoopStartEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStartEnhancedHueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeColorLoopStartEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStartEnhancedHueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeColorLoopStoredEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStoredEnhancedHueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeColorLoopStoredEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStoredEnhancedHueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeColorCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorCapabilitiesWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeColorCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorCapabilitiesWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeColorTempPhysicalMinMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMinMiredsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeColorTempPhysicalMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMinMiredsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeColorTempPhysicalMaxMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMaxMiredsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeColorTempPhysicalMaxMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMaxMiredsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCoupleColorTempToLevelMinMiredsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeCoupleColorTempToLevelMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCoupleColorTempToLevelMinMiredsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeStartUpColorTemperatureMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpColorTemperatureMiredsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeStartUpColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpColorTemperatureMiredsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributePhysicalMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhysicalMinLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhysicalMinLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePhysicalMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhysicalMaxLevelWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhysicalMaxLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBallastStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBallastStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBallastStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeIntrinsicBallastFactorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::IntrinsicBallastFactor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeIntrinsicBallastFactorWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeIntrinsicBallastFactorWithValue:(NSNumber * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeIntrinsicBallastFactorWithValue:(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::IntrinsicBallastFactor::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

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

- (void)subscribeAttributeIntrinsicBallastFactorWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::IntrinsicBallastFactor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeIntrinsicBallastFactorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::IntrinsicBallastFactor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBallastFactorAdjustmentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBallastFactorAdjustmentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLampQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLampQuantityWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLampQuantityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLampTypeWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLampTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLampManufacturerWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLampManufacturerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLampRatedHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLampRatedHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLampBurnHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLampBurnHoursWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLampAlarmModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLampAlarmModeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLampBurnHoursTripPointWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLampBurnHoursTripPointWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterBallastConfiguration (Deprecated)

- (void)readAttributePhysicalMinLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMinLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributePhysicalMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMinLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributePhysicalMaxLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMaxLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributePhysicalMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMaxLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeBallastStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeBallastStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeMaxLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeIntrinsicBalanceFactorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIntrinsicBallastFactorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeIntrinsicBallastFactorWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)value params:(MTRWriteParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeIntrinsicBallastFactorWithValue: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 subscribeAttributeIntrinsicBallastFactorWithParams:subscribeParams subscriptionEstablished:subscriptionEstablishedHandler reportHandler:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeIntrinsicBalanceFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIntrinsicBallastFactorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeBallastFactorAdjustmentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastFactorAdjustmentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeBallastFactorAdjustmentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastFactorAdjustmentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeLampQuantityWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampQuantityWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeLampQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampQuantityWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeLampTypeWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampTypeWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSString *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeLampTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSString *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeLampManufacturerWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampManufacturerWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeLampManufacturerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampManufacturerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeLampRatedHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampRatedHoursWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeLampRatedHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampRatedHoursWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeLampBurnHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeLampBurnHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeLampAlarmModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampAlarmModeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeLampAlarmModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampAlarmModeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeLampBurnHoursTripPointWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursTripPointWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeLampBurnHoursTripPointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursTripPointWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLightSensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLightSensorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLightSensorTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterIlluminanceMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeLightSensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLightSensorTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeLightSensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLightSensorTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterTemperatureMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScaledValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinScaledValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxScaledValueWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxScaledValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScaledToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScaledToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScaledToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScaleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScaleWithParams:(MTRSubscribeParams * _Nonnull)params
                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScaleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPressureMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeScaledValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeMinScaledValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinScaledValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeMinScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinScaledValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeMaxScaledValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxScaledValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeMaxScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxScaledValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeScaledToleranceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledToleranceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeScaledToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledToleranceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeScaleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaleWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeScaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterFlowMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeToleranceWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeToleranceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterRelativeHumidityMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOccupancyWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupancyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupancySensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOccupancySensorTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupancySensorTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOccupancySensorTypeBitmapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOccupancySensorTypeBitmapWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOccupancySensorTypeBitmapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePIROccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePIROccupiedToUnoccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePIRUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePIRUnoccupiedToOccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePIRUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePIRUnoccupiedToOccupiedThresholdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOccupancySensing (Deprecated)

- (void)readAttributeOccupancyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeOccupancySensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeOccupancySensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeOccupancySensorTypeBitmapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeBitmapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeOccupancySensorTypeBitmapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeBitmapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributePirOccupiedToUnoccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIROccupiedToUnoccupiedDelayWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributePirOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIROccupiedToUnoccupiedDelayWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributePirUnoccupiedToOccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIRUnoccupiedToOccupiedDelayWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributePirUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIRUnoccupiedToOccupiedDelayWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributePirUnoccupiedToOccupiedThresholdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIRUnoccupiedToOccupiedThresholdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}
+ (void)readAttributePirUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIRUnoccupiedToOccupiedThresholdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}

- (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}
+ (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicOccupiedToUnoccupiedDelayWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                        }];
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}
+ (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedDelayWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                        }];
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                         }];
}
+ (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                            }];
}

- (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                          }];
}
+ (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactOccupiedToUnoccupiedDelayWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                             }];
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                          }];
}
+ (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedDelayWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                             }];
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                              }];
}
+ (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                                 }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterCarbonMonoxideConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonMonoxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterCarbonDioxideConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = CarbonDioxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterNitrogenDioxideConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = NitrogenDioxideConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterOzoneConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = OzoneConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPM25ConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm25ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterFormaldehydeConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = FormaldehydeConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPM1ConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm1ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterPM10ConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Pm10ConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterTotalVolatileOrganicCompoundsConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TotalVolatileOrganicCompoundsConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterRadonConcentrationMeasurement

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMinMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMinMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MinMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMaxMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMaxMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::PeakMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePeakMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePeakMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePeakMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::PeakMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AverageMeasuredValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageMeasuredValueWindowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageMeasuredValueWindowWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageMeasuredValueWindowWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AverageMeasuredValueWindow::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUncertaintyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeUncertaintyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUncertaintyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::Uncertainty::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementUnitWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementUnitWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasurementUnit::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasurementMediumWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementMediumWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementMediumWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::MeasurementMedium::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLevelValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLevelValueWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLevelValueWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::LevelValue::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = RadonConcentrationMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterWakeOnLAN

- (void)readAttributeMACAddressWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMACAddressWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMACAddressWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLinkLocalAddressWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::LinkLocalAddress::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLinkLocalAddressWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::LinkLocalAddress::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLinkLocalAddressWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::LinkLocalAddress::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterWakeOnLan
@end

@implementation MTRBaseClusterWakeOnLan (Deprecated)

- (void)readAttributeMACAddressWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMACAddressWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeMACAddressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMACAddressWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params completion:(void (^)(MTRChannelClusterChangeChannelResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRChannelClusterChangeChannelParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Channel::Commands::ChangeChannel::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRChannelClusterChangeChannelResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRChannelClusterChangeChannelByNumberParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Channel::Commands::ChangeChannelByNumber::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRChannelClusterSkipChannelParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Channel::Commands::SkipChannel::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getProgramGuideWithCompletion:(void (^)(MTRChannelClusterProgramGuideResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self getProgramGuideWithParams:nil completion:completion];
}
- (void)getProgramGuideWithParams:(MTRChannelClusterGetProgramGuideParams * _Nullable)params completion:(void (^)(MTRChannelClusterProgramGuideResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRChannelClusterGetProgramGuideParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Channel::Commands::GetProgramGuide::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRChannelClusterProgramGuideResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)recordProgramWithParams:(MTRChannelClusterRecordProgramParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRChannelClusterRecordProgramParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Channel::Commands::RecordProgram::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)cancelRecordProgramWithParams:(MTRChannelClusterCancelRecordProgramParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRChannelClusterCancelRecordProgramParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = Channel::Commands::CancelRecordProgram::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeChannelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeChannelListWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeChannelListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLineupWithCompletion:(void (^)(MTRChannelClusterLineupInfoStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLineupWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(MTRChannelClusterLineupInfoStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLineupWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRChannelClusterLineupInfoStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentChannelWithCompletion:(void (^)(MTRChannelClusterChannelInfoStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentChannelWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(MTRChannelClusterChannelInfoStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentChannelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRChannelClusterChannelInfoStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterChannel (Deprecated)

- (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params completionHandler:(void (^)(MTRChannelClusterChangeChannelResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self changeChannelWithParams:params completion:
                                             ^(MTRChannelClusterChangeChannelResponseParams * _Nullable data, NSError * _Nullable error) {
                                                 // Cast is safe because subclass does not add any selectors.
                                                 completionHandler(static_cast<MTRChannelClusterChangeChannelResponseParams *>(data), error);
                                             }];
}
- (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:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeChannelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeLineupWithCompletionHandler:(void (^)(MTRChannelClusterLineupInfo * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineupWithCompletion:
              ^(MTRChannelClusterLineupInfoStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRChannelClusterLineupInfo *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(MTRChannelClusterLineupInfoStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<MTRChannelClusterLineupInfo *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeLineupWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRChannelClusterLineupInfo * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineupWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(MTRChannelClusterLineupInfoStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<MTRChannelClusterLineupInfo *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeCurrentChannelWithCompletionHandler:(void (^)(MTRChannelClusterChannelInfo * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentChannelWithCompletion:
              ^(MTRChannelClusterChannelInfoStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRChannelClusterChannelInfo *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(MTRChannelClusterChannelInfoStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<MTRChannelClusterChannelInfo *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeCurrentChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRChannelClusterChannelInfo * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentChannelWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(MTRChannelClusterChannelInfoStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<MTRChannelClusterChannelInfo *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams *)params completion:(void (^)(MTRTargetNavigatorClusterNavigateTargetResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRTargetNavigatorClusterNavigateTargetParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = TargetNavigator::Commands::NavigateTarget::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRTargetNavigatorClusterNavigateTargetResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeTargetListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTargetListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTargetListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentTargetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentTargetWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentTargetWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterTargetNavigator (Deprecated)

- (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams *)params completionHandler:(void (^)(MTRTargetNavigatorClusterNavigateTargetResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self navigateTargetWithParams:params completion:
                                              ^(MTRTargetNavigatorClusterNavigateTargetResponseParams * _Nullable data, NSError * _Nullable error) {
                                                  // Cast is safe because subclass does not add any selectors.
                                                  completionHandler(static_cast<MTRTargetNavigatorClusterNavigateTargetResponseParams *>(data), error);
                                              }];
}

- (void)readAttributeTargetListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeTargetListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeCurrentTargetWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentTargetWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeCurrentTargetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentTargetWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (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
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterPlayParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::Play::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (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
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterPauseParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::Pause::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self stopWithParams:nil completion:completion];
}
- (void)stopWithParams:(MTRMediaPlaybackClusterStopParams * _Nullable)params completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterStopParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::Stop::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (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
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterStartOverParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::StartOver::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (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
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterPreviousParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::Previous::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (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
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterNextParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::Next::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (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
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterRewindParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::Rewind::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (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
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterFastForwardParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::FastForward::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterSkipForwardParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::SkipForward::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)params completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterSkipBackwardParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::SkipBackward::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params completion:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterSeekParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::Seek::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRMediaPlaybackClusterPlaybackResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)activateAudioTrackWithParams:(MTRMediaPlaybackClusterActivateAudioTrackParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterActivateAudioTrackParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::ActivateAudioTrack::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)activateTextTrackWithParams:(MTRMediaPlaybackClusterActivateTextTrackParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterActivateTextTrackParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::ActivateTextTrack::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)deactivateTextTrackWithCompletion:(MTRStatusCompletion)completion
{
    [self deactivateTextTrackWithParams:nil completion:completion];
}
- (void)deactivateTextTrackWithParams:(MTRMediaPlaybackClusterDeactivateTextTrackParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMediaPlaybackClusterDeactivateTextTrackParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaPlayback::Commands::DeactivateTextTrack::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeCurrentStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentStateWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStartTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStartTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStartTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDurationWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSampledPositionWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackPositionStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSampledPositionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(MTRMediaPlaybackClusterPlaybackPositionStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSampledPositionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRMediaPlaybackClusterPlaybackPositionStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePlaybackSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePlaybackSpeedWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePlaybackSpeedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSeekRangeEndWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSeekRangeEndWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSeekRangeEndWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSeekRangeStartWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeSeekRangeStartWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSeekRangeStartWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveAudioTrackWithCompletion:(void (^)(MTRMediaPlaybackClusterTrackStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::ActiveAudioTrack::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveAudioTrackWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(MTRMediaPlaybackClusterTrackStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::ActiveAudioTrack::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveAudioTrackWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRMediaPlaybackClusterTrackStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::ActiveAudioTrack::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAvailableAudioTracksWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AvailableAudioTracks::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAvailableAudioTracksWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::AvailableAudioTracks::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAvailableAudioTracksWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AvailableAudioTracks::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveTextTrackWithCompletion:(void (^)(MTRMediaPlaybackClusterTrackStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::ActiveTextTrack::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveTextTrackWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(MTRMediaPlaybackClusterTrackStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::ActiveTextTrack::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveTextTrackWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRMediaPlaybackClusterTrackStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::ActiveTextTrack::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAvailableTextTracksWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AvailableTextTracks::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAvailableTextTracksWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::AvailableTextTracks::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAvailableTextTracksWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AvailableTextTracks::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterMediaPlayback (Deprecated)

- (void)playWithParams:(MTRMediaPlaybackClusterPlayParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self playWithParams:params completion:
                                    ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                        // Cast is safe because subclass does not add any selectors.
                                        completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                    }];
}
- (void)playWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self playWithParams:nil completionHandler:completionHandler];
}
- (void)pauseWithParams:(MTRMediaPlaybackClusterPauseParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self pauseWithParams:params completion:
                                     ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                         // Cast is safe because subclass does not add any selectors.
                                         completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                     }];
}
- (void)pauseWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self pauseWithParams:nil completionHandler:completionHandler];
}
- (void)stopPlaybackWithParams:(MTRMediaPlaybackClusterStopPlaybackParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self stopWithParams:params completion:
                                    ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                        // Cast is safe because subclass does not add any selectors.
                                        completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                    }];
}
- (void)stopPlaybackWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self stopPlaybackWithParams:nil completionHandler:completionHandler];
}
- (void)startOverWithParams:(MTRMediaPlaybackClusterStartOverParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self startOverWithParams:params completion:
                                         ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                             // Cast is safe because subclass does not add any selectors.
                                             completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                         }];
}
- (void)startOverWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self startOverWithParams:nil completionHandler:completionHandler];
}
- (void)previousWithParams:(MTRMediaPlaybackClusterPreviousParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self previousWithParams:params completion:
                                        ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                            // Cast is safe because subclass does not add any selectors.
                                            completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                        }];
}
- (void)previousWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self previousWithParams:nil completionHandler:completionHandler];
}
- (void)nextWithParams:(MTRMediaPlaybackClusterNextParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self nextWithParams:params completion:
                                    ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                        // Cast is safe because subclass does not add any selectors.
                                        completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                    }];
}
- (void)nextWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self nextWithParams:nil completionHandler:completionHandler];
}
- (void)rewindWithParams:(MTRMediaPlaybackClusterRewindParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self rewindWithParams:params completion:
                                      ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                          // Cast is safe because subclass does not add any selectors.
                                          completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                      }];
}
- (void)rewindWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self rewindWithParams:nil completionHandler:completionHandler];
}
- (void)fastForwardWithParams:(MTRMediaPlaybackClusterFastForwardParams * _Nullable)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self fastForwardWithParams:params completion:
                                           ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                               // Cast is safe because subclass does not add any selectors.
                                               completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                           }];
}
- (void)fastForwardWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self fastForwardWithParams:nil completionHandler:completionHandler];
}
- (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self skipForwardWithParams:params completion:
                                           ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                               // Cast is safe because subclass does not add any selectors.
                                               completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                           }];
}
- (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self skipBackwardWithParams:params completion:
                                            ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                                // Cast is safe because subclass does not add any selectors.
                                                completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                            }];
}
- (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self seekWithParams:params completion:
                                    ^(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error) {
                                        // Cast is safe because subclass does not add any selectors.
                                        completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackResponseParams *>(data), error);
                                    }];
}

- (void)readAttributeCurrentStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentStateWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeCurrentStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentStateWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeStartTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartTimeWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeStartTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartTimeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeDurationWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDurationWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDurationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeSampledPositionWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSampledPositionWithCompletion:
              ^(MTRMediaPlaybackClusterPlaybackPositionStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackPosition *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(MTRMediaPlaybackClusterPlaybackPositionStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<MTRMediaPlaybackClusterPlaybackPosition *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeSampledPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSampledPositionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(MTRMediaPlaybackClusterPlaybackPositionStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<MTRMediaPlaybackClusterPlaybackPosition *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributePlaybackSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePlaybackSpeedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributePlaybackSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePlaybackSpeedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeSeekRangeEndWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeEndWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeSeekRangeEndWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeEndWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeSeekRangeStartWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeStartWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeSeekRangeStartWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeStartWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMediaInputClusterSelectInputParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaInput::Commands::SelectInput::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)showInputStatusWithCompletion:(MTRStatusCompletion)completion
{
    [self showInputStatusWithParams:nil completion:completion];
}
- (void)showInputStatusWithParams:(MTRMediaInputClusterShowInputStatusParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMediaInputClusterShowInputStatusParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaInput::Commands::ShowInputStatus::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)hideInputStatusWithCompletion:(MTRStatusCompletion)completion
{
    [self hideInputStatusWithParams:nil completion:completion];
}
- (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMediaInputClusterHideInputStatusParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaInput::Commands::HideInputStatus::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRMediaInputClusterRenameInputParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = MediaInput::Commands::RenameInput::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeInputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInputListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInputListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentInputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentInputWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentInputWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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 completionHandler:completionHandler];
}
- (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self hideInputStatusWithParams:params completion:
                                               completionHandler];
}
- (void)hideInputStatusWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self hideInputStatusWithParams:nil completionHandler: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:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeInputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInputListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeCurrentInputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentInputWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeCurrentInputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentInputWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)sleepWithCompletion:(MTRStatusCompletion)completion
{
    [self sleepWithParams:nil completion:completion];
}
- (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRLowPowerClusterSleepParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = LowPower::Commands::Sleep::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LowPower::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterLowPower (Deprecated)

- (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self sleepWithParams:params completion:
                                     completionHandler];
}
- (void)sleepWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self sleepWithParams:nil completionHandler:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params completion:(void (^)(MTRKeypadInputClusterSendKeyResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRKeypadInputClusterSendKeyParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = KeypadInput::Commands::SendKey::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRKeypadInputClusterSendKeyResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = KeypadInput::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterKeypadInput (Deprecated)

- (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params completionHandler:(void (^)(MTRKeypadInputClusterSendKeyResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self sendKeyWithParams:params completion:
                                       ^(MTRKeypadInputClusterSendKeyResponseParams * _Nullable data, NSError * _Nullable error) {
                                           // Cast is safe because subclass does not add any selectors.
                                           completionHandler(static_cast<MTRKeypadInputClusterSendKeyResponseParams *>(data), error);
                                       }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)params completion:(void (^)(MTRContentLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRContentLauncherClusterLaunchContentParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentLauncher::Commands::LaunchContent::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRContentLauncherClusterLauncherResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params completion:(void (^)(MTRContentLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRContentLauncherClusterLaunchURLParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentLauncher::Commands::LaunchURL::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRContentLauncherClusterLauncherResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeAcceptHeaderWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptHeaderWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptHeaderWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeSupportedStreamingProtocolsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeSupportedStreamingProtocolsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentLauncher::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterContentLauncher (Deprecated)

- (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)params completionHandler:(void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self launchContentWithParams:params completion:
                                             ^(MTRContentLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error) {
                                                 // Cast is safe because subclass does not add any selectors.
                                                 completionHandler(static_cast<MTRContentLauncherClusterLaunchResponseParams *>(data), error);
                                             }];
}
- (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params completionHandler:(void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self launchURLWithParams:params completion:
                                         ^(MTRContentLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error) {
                                             // Cast is safe because subclass does not add any selectors.
                                             completionHandler(static_cast<MTRContentLauncherClusterLaunchResponseParams *>(data), error);
                                         }];
}

- (void)readAttributeAcceptHeaderWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptHeaderWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeAcceptHeaderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptHeaderWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeSupportedStreamingProtocolsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedStreamingProtocolsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeSupportedStreamingProtocolsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedStreamingProtocolsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRAudioOutputClusterSelectOutputParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = AudioOutput::Commands::SelectOutput::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRAudioOutputClusterRenameOutputParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = AudioOutput::Commands::RenameOutput::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeOutputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOutputListWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOutputListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentOutputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentOutputWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentOutputWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@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:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeOutputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutputListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeCurrentOutputWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOutputWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeCurrentOutputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOutputWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)launchAppWithCompletion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self launchAppWithParams:nil completion:completion];
}
- (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams * _Nullable)params completion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRApplicationLauncherClusterLaunchAppParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ApplicationLauncher::Commands::LaunchApp::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRApplicationLauncherClusterLauncherResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)stopAppWithCompletion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self stopAppWithParams:nil completion:completion];
}
- (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams * _Nullable)params completion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRApplicationLauncherClusterStopAppParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ApplicationLauncher::Commands::StopApp::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRApplicationLauncherClusterLauncherResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)hideAppWithCompletion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self hideAppWithParams:nil completion:completion];
}
- (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams * _Nullable)params completion:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRApplicationLauncherClusterHideAppParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ApplicationLauncher::Commands::HideApp::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRApplicationLauncherClusterLauncherResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeCatalogListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCatalogListWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCatalogListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentAppWithCompletion:(void (^)(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEPStruct * _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 = AsCharSpan(value.application.applicationID);
       if (value.endpoint != nil) {
         auto & definedValue_2 = nonNullValue_0.endpoint.Emplace();
                 definedValue_2 = value.endpoint.unsignedShortValue;
  }
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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 (^)(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentAppWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterApplicationLauncher (Deprecated)

- (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams * _Nullable)params completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self launchAppWithParams:params completion:
                                         ^(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error) {
                                             // Cast is safe because subclass does not add any selectors.
                                             completionHandler(static_cast<MTRApplicationLauncherClusterLauncherResponseParams *>(data), error);
                                         }];
}
- (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams * _Nullable)params completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self stopAppWithParams:params completion:
                                       ^(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error) {
                                           // Cast is safe because subclass does not add any selectors.
                                           completionHandler(static_cast<MTRApplicationLauncherClusterLauncherResponseParams *>(data), error);
                                       }];
}
- (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams * _Nullable)params completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self hideAppWithParams:params completion:
                                       ^(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data, NSError * _Nullable error) {
                                           // Cast is safe because subclass does not add any selectors.
                                           completionHandler(static_cast<MTRApplicationLauncherClusterLauncherResponseParams *>(data), error);
                                       }];
}

- (void)readAttributeCatalogListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCatalogListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeCatalogListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCatalogListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeCurrentAppWithCompletionHandler:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentAppWithCompletion:
              ^(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRApplicationLauncherClusterApplicationEP *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<MTRApplicationLauncherClusterApplicationEP *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeCurrentAppWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentAppWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(MTRApplicationLauncherClusterApplicationEPStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<MTRApplicationLauncherClusterApplicationEP *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVendorNameWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVendorNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVendorIDWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVendorIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApplicationNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApplicationNameWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApplicationNameWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeProductIDWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeProductIDWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApplicationWithCompletion:(void (^)(MTRApplicationBasicClusterApplicationStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApplicationWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(MTRApplicationBasicClusterApplicationStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApplicationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRApplicationBasicClusterApplicationStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeStatusWithParams:(MTRSubscribeParams * _Nonnull)params
                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStatusWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApplicationVersionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApplicationVersionWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApplicationVersionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAllowedVendorListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAllowedVendorListWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAllowedVendorListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterApplicationBasic (Deprecated)

- (void)readAttributeVendorNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeVendorIDWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeApplicationNameWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationNameWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeApplicationNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationNameWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeProductIDWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeApplicationWithCompletionHandler:(void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationWithCompletion:
              ^(MTRApplicationBasicClusterApplicationStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRApplicationBasicClusterApplicationBasicApplication *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(MTRApplicationBasicClusterApplicationStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<MTRApplicationBasicClusterApplicationBasicApplication *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeApplicationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(MTRApplicationBasicClusterApplicationStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<MTRApplicationBasicClusterApplicationBasicApplication *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeApplicationVersionWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationVersionWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeApplicationVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationVersionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeAllowedVendorListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAllowedVendorListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeAllowedVendorListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAllowedVendorListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

- (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params completion:(void (^)(MTRAccountLoginClusterGetSetupPINResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRAccountLoginClusterGetSetupPINParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = AccountLogin::Commands::GetSetupPIN::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRAccountLoginClusterGetSetupPINResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRAccountLoginClusterLoginParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = AccountLogin::Commands::Login::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)logoutWithCompletion:(MTRStatusCompletion)completion
{
    [self logoutWithParams:nil completion:completion];
}
- (void)logoutWithParams:(MTRAccountLoginClusterLogoutParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRAccountLoginClusterLogoutParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = AccountLogin::Commands::Logout::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccountLogin::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterAccountLogin (Deprecated)

- (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params completionHandler:(void (^)(MTRAccountLoginClusterGetSetupPINResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self getSetupPINWithParams:params completion:
                                           ^(MTRAccountLoginClusterGetSetupPINResponseParams * _Nullable data, NSError * _Nullable error) {
                                               // Cast is safe because subclass does not add any selectors.
                                               completionHandler(static_cast<MTRAccountLoginClusterGetSetupPINResponseParams *>(data), error);
                                           }];
}
- (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 completionHandler:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterContentControl

- (void)updatePINWithParams:(MTRContentControlClusterUpdatePINParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterUpdatePINParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::UpdatePIN::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)resetPINWithCompletion:(void (^)(MTRContentControlClusterResetPINResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self resetPINWithParams:nil completion:completion];
}
- (void)resetPINWithParams:(MTRContentControlClusterResetPINParams * _Nullable)params completion:(void (^)(MTRContentControlClusterResetPINResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterResetPINParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::ResetPIN::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRContentControlClusterResetPINResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)enableWithCompletion:(MTRStatusCompletion)completion
{
    [self enableWithParams:nil completion:completion];
}
- (void)enableWithParams:(MTRContentControlClusterEnableParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterEnableParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::Enable::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)disableWithCompletion:(MTRStatusCompletion)completion
{
    [self disableWithParams:nil completion:completion];
}
- (void)disableWithParams:(MTRContentControlClusterDisableParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterDisableParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::Disable::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addBonusTimeWithCompletion:(MTRStatusCompletion)completion
{
    [self addBonusTimeWithParams:nil completion:completion];
}
- (void)addBonusTimeWithParams:(MTRContentControlClusterAddBonusTimeParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterAddBonusTimeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::AddBonusTime::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setScreenDailyTimeWithParams:(MTRContentControlClusterSetScreenDailyTimeParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterSetScreenDailyTimeParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::SetScreenDailyTime::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)blockUnratedContentWithCompletion:(MTRStatusCompletion)completion
{
    [self blockUnratedContentWithParams:nil completion:completion];
}
- (void)blockUnratedContentWithParams:(MTRContentControlClusterBlockUnratedContentParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterBlockUnratedContentParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::BlockUnratedContent::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)unblockUnratedContentWithCompletion:(MTRStatusCompletion)completion
{
    [self unblockUnratedContentWithParams:nil completion:completion];
}
- (void)unblockUnratedContentWithParams:(MTRContentControlClusterUnblockUnratedContentParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterUnblockUnratedContentParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::UnblockUnratedContent::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setOnDemandRatingThresholdWithParams:(MTRContentControlClusterSetOnDemandRatingThresholdParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterSetOnDemandRatingThresholdParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::SetOnDemandRatingThreshold::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)setScheduledContentRatingThresholdWithParams:(MTRContentControlClusterSetScheduledContentRatingThresholdParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRContentControlClusterSetScheduledContentRatingThresholdParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentControl::Commands::SetScheduledContentRatingThreshold::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::Enabled::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEnabledWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::Enabled::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::Enabled::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnDemandRatingsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::OnDemandRatings::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOnDemandRatingsWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::OnDemandRatings::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnDemandRatingsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::OnDemandRatings::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOnDemandRatingThresholdWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::OnDemandRatingThreshold::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeOnDemandRatingThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::OnDemandRatingThreshold::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOnDemandRatingThresholdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::OnDemandRatingThreshold::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScheduledContentRatingsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ScheduledContentRatings::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScheduledContentRatingsWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::ScheduledContentRatings::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScheduledContentRatingsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ScheduledContentRatings::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScheduledContentRatingThresholdWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ScheduledContentRatingThreshold::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScheduledContentRatingThresholdWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::ScheduledContentRatingThreshold::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScheduledContentRatingThresholdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ScheduledContentRatingThreshold::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeScreenDailyTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ScreenDailyTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeScreenDailyTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::ScreenDailyTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeScreenDailyTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ScreenDailyTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRemainingScreenTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::RemainingScreenTime::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRemainingScreenTimeWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::RemainingScreenTime::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRemainingScreenTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::RemainingScreenTime::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBlockUnratedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::BlockUnrated::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeBlockUnratedWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::BlockUnrated::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBlockUnratedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::BlockUnrated::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentControl::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentControl::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterContentAppObserver

- (void)contentAppMessageWithParams:(MTRContentAppObserverClusterContentAppMessageParams *)params completion:(void (^)(MTRContentAppObserverClusterContentAppMessageResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRContentAppObserverClusterContentAppMessageParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ContentAppObserver::Commands::ContentAppMessage::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRContentAppObserverClusterContentAppMessageResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentAppObserver::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentAppObserver::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentAppObserver::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentAppObserver::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentAppObserver::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ContentAppObserver::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ContentAppObserver::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterElectricalMeasurement

- (void)getProfileInfoCommandWithCompletion:(MTRStatusCompletion)completion
{
    [self getProfileInfoCommandWithParams:nil completion:completion];
}
- (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfileInfoCommandParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRElectricalMeasurementClusterGetProfileInfoCommandParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ElectricalMeasurement::Commands::GetProfileInfoCommand::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams *)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeMeasurementTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasurementTypeWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasurementTypeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcVoltageMinWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcVoltageMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcVoltageMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcCurrentMinWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcCurrentMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcCurrentMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcPowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcPowerMinWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcPowerMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcPowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcPowerMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcPowerMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcVoltageMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcVoltageMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcVoltageDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcCurrentDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcPowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcPowerMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeDcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeDcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeDcPowerDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcFrequencyWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcFrequencyWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcFrequencyMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcFrequencyMinWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcFrequencyMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcFrequencyMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcFrequencyMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcFrequencyMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNeutralCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeNeutralCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNeutralCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTotalActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTotalActivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTotalActivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTotalReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTotalReactivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTotalReactivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTotalApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeTotalApparentPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTotalApparentPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasured1stHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasured1stHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasured1stHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasured3rdHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasured3rdHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasured3rdHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasured5thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasured5thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasured5thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasured7thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasured7thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasured7thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasured9thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasured9thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasured9thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasured11thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasured11thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasured11thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasuredPhase1stHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredPhase1stHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredPhase1stHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredPhase3rdHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasuredPhase5thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredPhase5thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredPhase5thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasuredPhase7thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredPhase7thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredPhase7thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasuredPhase9thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredPhase9thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredPhase9thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeasuredPhase11thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeMeasuredPhase11thHarmonicCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeasuredPhase11thHarmonicCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcFrequencyMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcFrequencyMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcFrequencyMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcFrequencyDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcFrequencyDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcFrequencyDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeHarmonicCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeHarmonicCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeHarmonicCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePhaseHarmonicCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePhaseHarmonicCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePhaseHarmonicCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstantaneousVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstantaneousVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstantaneousVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstantaneousLineCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstantaneousLineCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstantaneousLineCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstantaneousActiveCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstantaneousActiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstantaneousActiveCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstantaneousReactiveCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstantaneousReactiveCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstantaneousReactiveCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInstantaneousPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeInstantaneousPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInstantaneousPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageMinWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentMinWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerMinWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerMinWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerMaxWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerMaxWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReactivePowerWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReactivePowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApparentPowerWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApparentPowerWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerFactorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerFactorWithParams:(MTRSubscribeParams * _Nonnull)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerFactorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsUnderVoltageCounterWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsUnderVoltageCounterWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSagPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSagPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSwellPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSwellPeriodWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcVoltageMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcVoltageMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcVoltageDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcVoltageDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcCurrentMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcCurrentMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcCurrentDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcCurrentDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcPowerMultiplierWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcPowerMultiplierWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcPowerDivisorWithParams:(MTRSubscribeParams * _Nonnull)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcPowerDivisorWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOverloadAlarmsMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeVoltageOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVoltageOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeCurrentOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCurrentOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcOverloadAlarmsMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcVoltageOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcVoltageOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcCurrentOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcCurrentOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcActivePowerOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcActivePowerOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcActivePowerOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcReactivePowerOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcReactivePowerOverloadWithParams:(MTRSubscribeParams * _Nonnull)params
                                    subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                              reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcReactivePowerOverloadWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsOverVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsOverVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsUnderVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsUnderVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsUnderVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsExtremeOverVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeOverVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeUnderVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsExtremeUnderVoltageWithParams:(MTRSubscribeParams * _Nonnull)params
                                   subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                             reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeUnderVoltageWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSagWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageSagWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSagWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSwellWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageSwellWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSwellWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLineCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLineCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLineCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReactiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReactiveCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReactiveCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltagePhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltagePhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltagePhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageMinPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageMaxPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentMinPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentMaxPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerMinPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerMinPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerMaxPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerMaxPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReactivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReactivePowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReactivePowerPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApparentPowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApparentPowerPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApparentPowerPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerFactorPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerFactorPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerFactorPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSagPeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageSagPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSagPeriodPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageSwellPeriodPhaseBWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSwellPeriodPhaseBWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLineCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeLineCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLineCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActiveCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActiveCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReactiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReactiveCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                  subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                            reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReactiveCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltagePhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltagePhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltagePhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageMinPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageMaxPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentMinPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsCurrentMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsCurrentMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsCurrentMaxPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerMinPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerMinPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeActivePowerMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeActivePowerMaxPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeActivePowerMaxPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeReactivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeReactivePowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeReactivePowerPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeApparentPowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeApparentPowerPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeApparentPowerPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributePowerFactorPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributePowerFactorPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributePowerFactorPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                          reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                         reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSagPeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageSagPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSagPeriodPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeRmsVoltageSwellPeriodPhaseCWithParams:(MTRSubscribeParams * _Nonnull)params
                                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRmsVoltageSwellPeriodPhaseCWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterElectricalMeasurement (Deprecated)

- (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfileInfoCommandParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self getProfileInfoCommandWithParams:params completion:
                                                     completionHandler];
}
- (void)getProfileInfoCommandWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self getProfileInfoCommandWithParams:nil completionHandler: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:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeMeasurementTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasurementTypeWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeDcVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeDcVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeDcVoltageMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeDcVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeDcVoltageMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeDcVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeDcCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeDcCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeDcCurrentMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeDcCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeDcCurrentMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributeDcCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeDcPowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeDcPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeDcPowerMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeDcPowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeDcPowerMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeDcPowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeDcVoltageMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeDcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeDcVoltageDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeDcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeDcCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeDcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeDcCurrentDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeDcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeDcPowerMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeDcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeDcPowerDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeDcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeAcFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeAcFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeAcFrequencyMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeAcFrequencyMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeAcFrequencyMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeAcFrequencyMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNeutralCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNeutralCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNeutralCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNeutralCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeTotalActivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalActivePowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeTotalActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalActivePowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeTotalReactivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalReactivePowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeTotalReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalReactivePowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeTotalApparentPowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalApparentPowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeTotalApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalApparentPowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeMeasured1stHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured1stHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeMeasured1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured1stHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeMeasured3rdHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured3rdHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeMeasured3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured3rdHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeMeasured5thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured5thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeMeasured5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured5thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeMeasured7thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured7thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeMeasured7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured7thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeMeasured9thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured9thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeMeasured9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured9thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeMeasured11thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured11thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeMeasured11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured11thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeMeasuredPhase1stHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase1stHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeMeasuredPhase1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase1stHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase3rdHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeMeasuredPhase5thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase5thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeMeasuredPhase5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase5thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeMeasuredPhase7thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase7thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeMeasuredPhase7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase7thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeMeasuredPhase9thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase9thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeMeasuredPhase9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase9thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeMeasuredPhase11thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase11thHarmonicCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}
+ (void)readAttributeMeasuredPhase11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase11thHarmonicCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}

- (void)readAttributeAcFrequencyMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeAcFrequencyMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeAcFrequencyDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeAcFrequencyDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributePowerMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributePowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributePowerDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                              }];
}
+ (void)readAttributePowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}

- (void)readAttributeHarmonicCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHarmonicCurrentMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHarmonicCurrentMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributePhaseHarmonicCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhaseHarmonicCurrentMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}
+ (void)readAttributePhaseHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhaseHarmonicCurrentMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                   }];
}

- (void)readAttributeInstantaneousVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeInstantaneousVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeInstantaneousLineCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousLineCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}
+ (void)readAttributeInstantaneousLineCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousLineCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}

- (void)readAttributeInstantaneousActiveCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousActiveCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}
+ (void)readAttributeInstantaneousActiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousActiveCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}

- (void)readAttributeInstantaneousReactiveCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousReactiveCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeInstantaneousReactiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousReactiveCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeInstantaneousPowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousPowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeInstantaneousPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousPowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeRmsVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeRmsVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeRmsVoltageMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRmsVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRmsVoltageMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRmsVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRmsCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeRmsCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeRmsCurrentMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRmsCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRmsCurrentMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRmsCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeActivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeActivePowerMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeActivePowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeActivePowerMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeActivePowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeReactivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeApparentPowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributePowerFactorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributePowerFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}
+ (void)readAttributeAverageRmsVoltageMeasurementPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                       }];
}

- (void)readAttributeAverageRmsUnderVoltageCounterWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeAverageRmsUnderVoltageCounterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeRmsExtremeOverVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeRmsExtremeUnderVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeRmsVoltageSagPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsVoltageSagPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRmsVoltageSwellPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeRmsVoltageSwellPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeAcVoltageMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAcVoltageDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeAcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeAcCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAcCurrentDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeAcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeAcPowerMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerMultiplierWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeAcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerMultiplierWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeAcPowerDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerDivisorWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeAcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerDivisorWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeOverloadAlarmsMaskWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverloadAlarmsMaskWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverloadAlarmsMaskWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeVoltageOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVoltageOverloadWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVoltageOverloadWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeCurrentOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOverloadWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOverloadWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeAcOverloadAlarmsMaskWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcOverloadAlarmsMaskWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeAcOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcOverloadAlarmsMaskWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcVoltageOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageOverloadWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeAcVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageOverloadWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeAcCurrentOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentOverloadWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeAcCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentOverloadWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeAcActivePowerOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcActivePowerOverloadWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeAcActivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcActivePowerOverloadWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeAcReactivePowerOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcReactivePowerOverloadWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}
+ (void)readAttributeAcReactivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcReactivePowerOverloadWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                            }];
}

- (void)readAttributeAverageRmsOverVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeAverageRmsOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeAverageRmsUnderVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeAverageRmsUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeRmsExtremeOverVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeRmsExtremeOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeRmsExtremeUnderVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltageWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}
+ (void)readAttributeRmsExtremeUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltageWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}

- (void)readAttributeRmsVoltageSagWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeRmsVoltageSagWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeRmsVoltageSwellWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeRmsVoltageSwellWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeLineCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeLineCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeActiveCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeActiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeReactiveCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeReactiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeRmsVoltagePhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeRmsVoltagePhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeRmsVoltageMinPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsVoltageMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRmsVoltageMaxPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsVoltageMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRmsCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeRmsCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeRmsCurrentMinPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsCurrentMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRmsCurrentMaxPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsCurrentMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeActivePowerPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeActivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeActivePowerMinPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeActivePowerMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeActivePowerMaxPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeActivePowerMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeReactivePowerPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeReactivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeApparentPowerPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeApparentPowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributePowerFactorPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePowerFactorPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                          }];
}
+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                             }];
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}
+ (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                       }];
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}
+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                        }];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                   }];
}
+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                      }];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}
+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                       }];
}

- (void)readAttributeRmsVoltageSagPeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeRmsVoltageSagPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseBWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeRmsVoltageSwellPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseBWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeLineCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeLineCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeActiveCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeActiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeReactiveCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeReactiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeRmsVoltagePhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeRmsVoltagePhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeRmsVoltageMinPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsVoltageMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRmsVoltageMaxPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsVoltageMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRmsCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeRmsCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeRmsCurrentMinPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsCurrentMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeRmsCurrentMaxPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeRmsCurrentMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeActivePowerPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeActivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeActivePowerMinPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeActivePowerMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeActivePowerMaxPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeActivePowerMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeReactivePowerPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeReactivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeApparentPowerPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeApparentPowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributePowerFactorPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributePowerFactorPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                          }];
}
+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                             }];
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}
+ (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                       }];
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                     }];
}
+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                        }];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                   }];
}
+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                      }];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                    }];
}
+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                                           completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                       }];
}

- (void)readAttributeRmsVoltageSagPeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                                               reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                           }];
}
+ (void)readAttributeRmsVoltageSagPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseCWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                             }];
}
+ (void)readAttributeRmsVoltageSwellPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseCWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterUnitTesting

- (void)testWithCompletion:(MTRStatusCompletion)completion
{
    [self testWithParams:nil completion:completion];
}
- (void)testWithParams:(MTRUnitTestingClusterTestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::Test::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testNotHandledWithCompletion:(MTRStatusCompletion)completion
{
    [self testNotHandledWithParams:nil completion:completion];
}
- (void)testNotHandledWithParams:(MTRUnitTestingClusterTestNotHandledParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestNotHandledParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestNotHandled::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testSpecificWithCompletion:(void (^)(MTRUnitTestingClusterTestSpecificResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self testSpecificWithParams:nil completion:completion];
}
- (void)testSpecificWithParams:(MTRUnitTestingClusterTestSpecificParams * _Nullable)params completion:(void (^)(MTRUnitTestingClusterTestSpecificResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestSpecificParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestSpecific::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestSpecificResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testUnknownCommandWithCompletion:(MTRStatusCompletion)completion
{
    [self testUnknownCommandWithParams:nil completion:completion];
}
- (void)testUnknownCommandWithParams:(MTRUnitTestingClusterTestUnknownCommandParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestUnknownCommandParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestUnknownCommand::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testAddArgumentsWithParams:(MTRUnitTestingClusterTestAddArgumentsParams *)params completion:(void (^)(MTRUnitTestingClusterTestAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestAddArgumentsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestAddArguments::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestAddArgumentsResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testSimpleArgumentRequestWithParams:(MTRUnitTestingClusterTestSimpleArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestSimpleArgumentResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestSimpleArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestSimpleArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestSimpleArgumentResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testStructArrayArgumentRequestWithParams:(MTRUnitTestingClusterTestStructArrayArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestStructArrayArgumentResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestStructArrayArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestStructArrayArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestStructArrayArgumentResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testStructArgumentRequestWithParams:(MTRUnitTestingClusterTestStructArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestStructArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestStructArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterBooleanResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testNestedStructArgumentRequestWithParams:(MTRUnitTestingClusterTestNestedStructArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestNestedStructArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestNestedStructArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterBooleanResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testListStructArgumentRequestWithParams:(MTRUnitTestingClusterTestListStructArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestListStructArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestListStructArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterBooleanResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testListInt8UArgumentRequestWithParams:(MTRUnitTestingClusterTestListInt8UArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestListInt8UArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestListInt8UArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterBooleanResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testNestedStructListArgumentRequestWithParams:(MTRUnitTestingClusterTestNestedStructListArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestNestedStructListArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestNestedStructListArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterBooleanResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testListNestedStructListArgumentRequestWithParams:(MTRUnitTestingClusterTestListNestedStructListArgumentRequestParams *)params completion:(void (^)(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestListNestedStructListArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestListNestedStructListArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterBooleanResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testListInt8UReverseRequestWithParams:(MTRUnitTestingClusterTestListInt8UReverseRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestListInt8UReverseResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestListInt8UReverseRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestListInt8UReverseRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestListInt8UReverseResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testEnumsRequestWithParams:(MTRUnitTestingClusterTestEnumsRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestEnumsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestEnumsRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestEnumsRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestEnumsResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testNullableOptionalRequestWithCompletion:(void (^)(MTRUnitTestingClusterTestNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    [self testNullableOptionalRequestWithParams:nil completion:completion];
}
- (void)testNullableOptionalRequestWithParams:(MTRUnitTestingClusterTestNullableOptionalRequestParams * _Nullable)params completion:(void (^)(MTRUnitTestingClusterTestNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestNullableOptionalRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestNullableOptionalRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestNullableOptionalResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testComplexNullableOptionalRequestWithParams:(MTRUnitTestingClusterTestComplexNullableOptionalRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestComplexNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestComplexNullableOptionalRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestComplexNullableOptionalRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestComplexNullableOptionalResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)simpleStructEchoRequestWithParams:(MTRUnitTestingClusterSimpleStructEchoRequestParams *)params completion:(void (^)(MTRUnitTestingClusterSimpleStructResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterSimpleStructEchoRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::SimpleStructEchoRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterSimpleStructResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)timedInvokeRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self timedInvokeRequestWithParams:nil completion:completion];
}
- (void)timedInvokeRequestWithParams:(MTRUnitTestingClusterTimedInvokeRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTimedInvokeRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;
    if (timedInvokeTimeoutMs == nil) {
        timedInvokeTimeoutMs = @(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
    }

    using RequestType = UnitTesting::Commands::TimedInvokeRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testSimpleOptionalArgumentRequestWithCompletion:(MTRStatusCompletion)completion
{
    [self testSimpleOptionalArgumentRequestWithParams:nil completion:completion];
}
- (void)testSimpleOptionalArgumentRequestWithParams:(MTRUnitTestingClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestSimpleOptionalArgumentRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestSimpleOptionalArgumentRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testEmitTestEventRequestWithParams:(MTRUnitTestingClusterTestEmitTestEventRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestEmitTestEventResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestEmitTestEventRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestEmitTestEventRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestEmitTestEventResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testEmitTestFabricScopedEventRequestWithParams:(MTRUnitTestingClusterTestEmitTestFabricScopedEventRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestEmitTestFabricScopedEventResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestEmitTestFabricScopedEventRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestEmitTestFabricScopedEventRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestEmitTestFabricScopedEventResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testBatchHelperRequestWithParams:(MTRUnitTestingClusterTestBatchHelperRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestBatchHelperResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestBatchHelperRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestBatchHelperRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestBatchHelperResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testSecondBatchHelperRequestWithParams:(MTRUnitTestingClusterTestSecondBatchHelperRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestBatchHelperResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestSecondBatchHelperRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestSecondBatchHelperRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestBatchHelperResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)testDifferentVendorMeiRequestWithParams:(MTRUnitTestingClusterTestDifferentVendorMeiRequestParams *)params completion:(void (^)(MTRUnitTestingClusterTestDifferentVendorMeiResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRUnitTestingClusterTestDifferentVendorMeiRequestParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = UnitTesting::Commands::TestDifferentVendorMeiRequest::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRUnitTestingClusterTestDifferentVendorMeiResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Boolean::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Boolean::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.boolValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Boolean::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Boolean::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap8::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Bitmap8::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Bitmap8::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBitmap8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap8::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap16::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Bitmap16::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Bitmap16::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBitmap16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap16::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap32::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Bitmap32::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Bitmap32::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBitmap32WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap32::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap64::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Bitmap64::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedLongLongValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Bitmap64::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeBitmap64WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Bitmap64::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int8u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int8u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int8u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int8u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int16u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int16u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedShortValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int16u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int16u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int24u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int24u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedIntValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int24u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt24uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int24u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int32u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int32u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedIntValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int32u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt32uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int32u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int40u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int40u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedLongLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int40u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt40uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int40u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int48u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int48u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedLongLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int48u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt48uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int48u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int56u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int56u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedLongLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int56u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt56uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int56u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int64u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int64u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedLongLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int64u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt64uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int64u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int8s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int8s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.charValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int8s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int8s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int16s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int16s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.shortValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int16s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int16s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int24s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int24s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.intValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int24s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt24sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int24s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int32s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int32s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.intValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int32s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt32sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int32s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int40s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int40s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.longLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int40s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt40sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int40s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int48s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int48s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.longLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int48s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt48sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int48s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int56s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int56s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.longLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int56s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt56sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int56s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int64s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Int64s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.longLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Int64s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeInt64sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Int64s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Enum8::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Enum8::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Enum8::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnum8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Enum8::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Enum16::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Enum16::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedShortValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Enum16::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnum16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Enum16::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::FloatSingle::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::FloatSingle::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.floatValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::FloatSingle::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFloatSingleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::FloatSingle::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::FloatDouble::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::FloatDouble::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.doubleValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::FloatDouble::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFloatDoubleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::FloatDouble::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::OctetString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::OctetString::TypeInfo;
        TypeInfo::Type cppValue;
          cppValue = AsByteSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::OctetString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::OctetString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeListInt8uWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListInt8u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::ListInt8u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeListInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListInt8u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeListOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListOctetString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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] = AsByteSpan(element_0);
              }
              cppValue = ListType_0(listHolder_0->mList, value.count);
            } else {
              cppValue = ListType_0();
            }
          }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::ListOctetString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeListOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListOctetString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeListStructOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListStructOctetString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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: [MTRUnitTestingClusterTestListStructOctet class]] ) {
                  // Wrong kind of value.
                  return CHIP_ERROR_INVALID_ARGUMENT;
                }
                auto element_0 = (MTRUnitTestingClusterTestListStructOctet *)value[i_0];
                             listHolder_0->mList[i_0].member1 = element_0.member1.unsignedLongLongValue;
       listHolder_0->mList[i_0].member2 = AsByteSpan(element_0.member2);
      }
              cppValue = ListType_0(listHolder_0->mList, value.count);
            } else {
              cppValue = ListType_0();
            }
          }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::ListStructOctetString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeListStructOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListStructOctetString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLongOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::LongOctetString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::LongOctetString::TypeInfo;
        TypeInfo::Type cppValue;
          cppValue = AsByteSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::LongOctetString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLongOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::LongOctetString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::CharString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::CharString::TypeInfo;
        TypeInfo::Type cppValue;
          cppValue = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::CharString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeCharStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::CharString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeLongCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::LongCharString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::LongCharString::TypeInfo;
        TypeInfo::Type cppValue;
          cppValue = AsCharSpan(value);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::LongCharString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeLongCharStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::LongCharString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEpochUsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EpochUs::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::EpochUs::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedLongLongValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::EpochUs::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEpochUsWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EpochUs::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEpochSWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EpochS::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::EpochS::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedIntValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::EpochS::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEpochSWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EpochS::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::VendorId::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::VendorId::TypeInfo;
        TypeInfo::Type cppValue;
              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::VendorId::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeVendorIdWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::VendorId::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeListNullablesAndOptionalsStructWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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: [MTRUnitTestingClusterNullablesAndOptionalsStruct class]] ) {
                  // Wrong kind of value.
                  return CHIP_ERROR_INVALID_ARGUMENT;
                }
                auto element_0 = (MTRUnitTestingClusterNullablesAndOptionalsStruct *)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 = AsCharSpan(element_0.nullableString);
       }
       if (element_0.optionalString != nil) {
         auto & definedValue_2 = listHolder_0->mList[i_0].optionalString.Emplace();
           definedValue_2 = 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 = 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 = AsByteSpan(element_0.nullableStruct.d);
       nonNullValue_2.e = 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 = AsByteSpan(element_0.optionalStruct.d);
       definedValue_2.e = 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 = AsByteSpan(element_0.nullableOptionalStruct.d);
       nonNullValue_3.e = 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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeListNullablesAndOptionalsStructWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EnumAttr::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::EnumAttr::TypeInfo;
        TypeInfo::Type cppValue;
              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::EnumAttr::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEnumAttrWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EnumAttr::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeStructAttrWithCompletion:(void (^)(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::StructAttr::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeStructAttrWithValue:(MTRUnitTestingClusterSimpleStruct * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeStructAttrWithValue:(MTRUnitTestingClusterSimpleStruct * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeStructAttrWithValue:(MTRUnitTestingClusterSimpleStruct * _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 = UnitTesting::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 = AsByteSpan(value.d);
       cppValue.e = 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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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 (^)(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::StructAttr::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeStructAttrWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::StructAttr::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::RangeRestrictedInt8u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRangeRestrictedInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::RangeRestrictedInt8s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.charValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRangeRestrictedInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::RangeRestrictedInt16u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedShortValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRangeRestrictedInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::RangeRestrictedInt16s::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.shortValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeRangeRestrictedInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeListLongOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListLongOctetString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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] = AsByteSpan(element_0);
              }
              cppValue = ListType_0(listHolder_0->mList, value.count);
            } else {
              cppValue = ListType_0();
            }
          }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::ListLongOctetString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeListLongOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListLongOctetString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeListFabricScopedWithParams:(MTRReadParams * _Nullable)params completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListFabricScoped::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:params
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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: [MTRUnitTestingClusterTestFabricScoped class]] ) {
                  // Wrong kind of value.
                  return CHIP_ERROR_INVALID_ARGUMENT;
                }
                auto element_0 = (MTRUnitTestingClusterTestFabricScoped *)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 = 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 = AsByteSpan(element_0.fabricSensitiveStruct.d);
       listHolder_0->mList[i_0].fabricSensitiveStruct.e = 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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::ListFabricScoped::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeListFabricScopedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ListFabricScoped::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeTimedWriteBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::TimedWriteBoolean::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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);
          }
        }
        if (!timedWriteTimeout.HasValue()) {
          timedWriteTimeout.SetValue(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
        }

        ListFreer listFreer;
        using TypeInfo = UnitTesting::Attributes::TimedWriteBoolean::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.boolValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::TimedWriteBoolean::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeTimedWriteBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::TimedWriteBoolean::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneralErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::GeneralErrorBoolean::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::GeneralErrorBoolean::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.boolValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::GeneralErrorBoolean::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneralErrorBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::GeneralErrorBoolean::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ClusterErrorBoolean::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::ClusterErrorBoolean::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.boolValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::ClusterErrorBoolean::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterErrorBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ClusterErrorBoolean::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeUnsupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Unsupported::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::Unsupported::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.boolValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::Unsupported::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeUnsupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::Unsupported::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBoolean::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableBoolean::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.boolValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableBoolean::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableBooleanWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBoolean::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap8::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap8::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableBitmap8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap8::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap16::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap16::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableBitmap16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap16::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap32::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap32::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableBitmap32WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap32::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap64::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap64::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableBitmap64WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableBitmap64::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt8u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt8u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt8u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt8u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt16u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt16u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedShortValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt16u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt16u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt24u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt24u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedIntValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt24u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt24uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt24u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt32u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt32u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedIntValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt32u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt32uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt32u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt40u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt40u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedLongLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt40u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt40uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt40u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt48u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt48u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedLongLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt48u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt48uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt48u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt56u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt56u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedLongLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt56u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt56uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt56u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt64u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt64u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedLongLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt64u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt64uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt64u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt8s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt8s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.charValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt8s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt8s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt16s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt16s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.shortValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt16s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt16s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt24s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt24s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.intValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt24s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt24sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt24s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt32s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt32s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.intValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt32s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt32sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt32s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt40s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt40s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.longLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt40s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt40sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt40s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt48s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt48s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.longLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt48s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt48sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt48s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt56s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt56s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.longLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt56s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt56sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt56s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt64s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableInt64s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.longLongValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableInt64s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableInt64sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableInt64s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableEnum8::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableEnum8::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableEnum8::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableEnum8WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableEnum8::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableEnum16::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableEnum16::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedShortValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableEnum16::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableEnum16WithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableEnum16::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableFloatSingle::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableFloatSingle::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.floatValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableFloatSingle::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableFloatSingleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableFloatSingle::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableFloatDouble::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableFloatDouble::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.doubleValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableFloatDouble::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableFloatDoubleWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableFloatDouble::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableOctetString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableOctetString::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
              nonNullValue_0 = AsByteSpan(value);
          }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableOctetString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableOctetStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableOctetString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableCharString::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableCharString::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
              nonNullValue_0 = AsCharSpan(value);
          }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableCharString::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableCharStringWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableCharString::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableEnumAttr::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableEnumAttr::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableEnumAttrWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableEnumAttr::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableStructWithCompletion:(void (^)(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableStruct::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeNullableStructWithValue:(MTRUnitTestingClusterSimpleStruct * _Nullable)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeNullableStructWithValue:(MTRUnitTestingClusterSimpleStruct * _Nullable) value params:nil completion:completion];
}
- (void)writeAttributeNullableStructWithValue:(MTRUnitTestingClusterSimpleStruct * _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 = UnitTesting::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 = AsByteSpan(value.d);
       nonNullValue_0.e = 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::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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 (^)(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::NullableStruct::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableStructWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableStruct::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedCharValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableRangeRestrictedInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.charValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableRangeRestrictedInt8sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.unsignedShortValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableRangeRestrictedInt16uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeNullableRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
        TypeInfo::Type cppValue;
          if (value == nil) {
            cppValue.SetNull();
          } else {
            auto & nonNullValue_0 = cppValue.SetNonNull();
                    nonNullValue_0 = value.shortValue;
  }

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeNullableRangeRestrictedInt16sWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeWriteOnlyInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::WriteOnlyInt8u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (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 = UnitTesting::Attributes::WriteOnlyInt8u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpointID.unsignedShortValue);
        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
{
    using TypeInfo = UnitTesting::Attributes::WriteOnlyInt8u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeWriteOnlyInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::WriteOnlyInt8u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeMeiInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::MeiInt8u::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeMeiInt8uWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeMeiInt8uWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeMeiInt8uWithValue:(NSNumber * _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 = UnitTesting::Attributes::MeiInt8u::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.unsignedCharValue;

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

- (void)subscribeAttributeMeiInt8uWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = UnitTesting::Attributes::MeiInt8u::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeMeiInt8uWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = UnitTesting::Attributes::MeiInt8u::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

@implementation MTRBaseClusterTestCluster
@end

@implementation MTRBaseClusterTestCluster (Deprecated)

- (void)testWithParams:(MTRTestClusterClusterTestParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testWithParams:params completion:
                                    completionHandler];
}
- (void)testWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self testWithParams:nil completionHandler:completionHandler];
}
- (void)testNotHandledWithParams:(MTRTestClusterClusterTestNotHandledParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testNotHandledWithParams:params completion:
                                              completionHandler];
}
- (void)testNotHandledWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self testNotHandledWithParams:nil completionHandler:completionHandler];
}
- (void)testSpecificWithParams:(MTRTestClusterClusterTestSpecificParams * _Nullable)params completionHandler:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testSpecificWithParams:params completion:
                                            ^(MTRUnitTestingClusterTestSpecificResponseParams * _Nullable data, NSError * _Nullable error) {
                                                // Cast is safe because subclass does not add any selectors.
                                                completionHandler(static_cast<MTRTestClusterClusterTestSpecificResponseParams *>(data), error);
                                            }];
}
- (void)testSpecificWithCompletionHandler:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testSpecificWithParams:nil completionHandler:completionHandler];
}
- (void)testUnknownCommandWithParams:(MTRTestClusterClusterTestUnknownCommandParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testUnknownCommandWithParams:params completion:
                                                  completionHandler];
}
- (void)testUnknownCommandWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self testUnknownCommandWithParams:nil completionHandler:completionHandler];
}
- (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testAddArgumentsWithParams:params completion:
                                                ^(MTRUnitTestingClusterTestAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error) {
                                                    // Cast is safe because subclass does not add any selectors.
                                                    completionHandler(static_cast<MTRTestClusterClusterTestAddArgumentsResponseParams *>(data), error);
                                                }];
}
- (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestSimpleArgumentResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testSimpleArgumentRequestWithParams:params completion:
                                                         ^(MTRUnitTestingClusterTestSimpleArgumentResponseParams * _Nullable data, NSError * _Nullable error) {
                                                             // Cast is safe because subclass does not add any selectors.
                                                             completionHandler(static_cast<MTRTestClusterClusterTestSimpleArgumentResponseParams *>(data), error);
                                                         }];
}
- (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStructArrayArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestStructArrayArgumentResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testStructArrayArgumentRequestWithParams:params completion:
                                                              ^(MTRUnitTestingClusterTestStructArrayArgumentResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                  // Cast is safe because subclass does not add any selectors.
                                                                  completionHandler(static_cast<MTRTestClusterClusterTestStructArrayArgumentResponseParams *>(data), error);
                                                              }];
}
- (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testStructArgumentRequestWithParams:params completion:
                                                         ^(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error) {
                                                             // Cast is safe because subclass does not add any selectors.
                                                             completionHandler(static_cast<MTRTestClusterClusterBooleanResponseParams *>(data), error);
                                                         }];
}
- (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testNestedStructArgumentRequestWithParams:params completion:
                                                               ^(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                   // Cast is safe because subclass does not add any selectors.
                                                                   completionHandler(static_cast<MTRTestClusterClusterBooleanResponseParams *>(data), error);
                                                               }];
}
- (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListStructArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testListStructArgumentRequestWithParams:params completion:
                                                             ^(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                 // Cast is safe because subclass does not add any selectors.
                                                                 completionHandler(static_cast<MTRTestClusterClusterBooleanResponseParams *>(data), error);
                                                             }];
}
- (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt8UArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testListInt8UArgumentRequestWithParams:params completion:
                                                            ^(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                // Cast is safe because subclass does not add any selectors.
                                                                completionHandler(static_cast<MTRTestClusterClusterBooleanResponseParams *>(data), error);
                                                            }];
}
- (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructListArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testNestedStructListArgumentRequestWithParams:params completion:
                                                                   ^(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                       // Cast is safe because subclass does not add any selectors.
                                                                       completionHandler(static_cast<MTRTestClusterClusterBooleanResponseParams *>(data), error);
                                                                   }];
}
- (void)testListNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTestListNestedStructListArgumentRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testListNestedStructListArgumentRequestWithParams:params completion:
                                                                       ^(MTRUnitTestingClusterBooleanResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                           // Cast is safe because subclass does not add any selectors.
                                                                           completionHandler(static_cast<MTRTestClusterClusterBooleanResponseParams *>(data), error);
                                                                       }];
}
- (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8UReverseRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestListInt8UReverseResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testListInt8UReverseRequestWithParams:params completion:
                                                           ^(MTRUnitTestingClusterTestListInt8UReverseResponseParams * _Nullable data, NSError * _Nullable error) {
                                                               // Cast is safe because subclass does not add any selectors.
                                                               completionHandler(static_cast<MTRTestClusterClusterTestListInt8UReverseResponseParams *>(data), error);
                                                           }];
}
- (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestEnumsResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testEnumsRequestWithParams:params completion:
                                                ^(MTRUnitTestingClusterTestEnumsResponseParams * _Nullable data, NSError * _Nullable error) {
                                                    // Cast is safe because subclass does not add any selectors.
                                                    completionHandler(static_cast<MTRTestClusterClusterTestEnumsResponseParams *>(data), error);
                                                }];
}
- (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullableOptionalRequestParams * _Nullable)params completionHandler:(void (^)(MTRTestClusterClusterTestNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testNullableOptionalRequestWithParams:params completion:
                                                           ^(MTRUnitTestingClusterTestNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error) {
                                                               // Cast is safe because subclass does not add any selectors.
                                                               completionHandler(static_cast<MTRTestClusterClusterTestNullableOptionalResponseParams *>(data), error);
                                                           }];
}
- (void)testNullableOptionalRequestWithCompletionHandler:(void (^)(MTRTestClusterClusterTestNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testNullableOptionalRequestWithParams:nil completionHandler:completionHandler];
}
- (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestComplexNullableOptionalRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestComplexNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testComplexNullableOptionalRequestWithParams:params completion:
                                                                  ^(MTRUnitTestingClusterTestComplexNullableOptionalResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                      // Cast is safe because subclass does not add any selectors.
                                                                      completionHandler(static_cast<MTRTestClusterClusterTestComplexNullableOptionalResponseParams *>(data), error);
                                                                  }];
}
- (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEchoRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterSimpleStructResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self simpleStructEchoRequestWithParams:params completion:
                                                       ^(MTRUnitTestingClusterSimpleStructResponseParams * _Nullable data, NSError * _Nullable error) {
                                                           // Cast is safe because subclass does not add any selectors.
                                                           completionHandler(static_cast<MTRTestClusterClusterSimpleStructResponseParams *>(data), error);
                                                       }];
}
- (void)timedInvokeRequestWithParams:(MTRTestClusterClusterTimedInvokeRequestParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self timedInvokeRequestWithParams:params completion:
                                                  completionHandler];
}
- (void)timedInvokeRequestWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self timedInvokeRequestWithParams:nil completionHandler:completionHandler];
}
- (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testSimpleOptionalArgumentRequestWithParams:params completion:
                                                                 completionHandler];
}
- (void)testSimpleOptionalArgumentRequestWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self testSimpleOptionalArgumentRequestWithParams:nil completionHandler:completionHandler];
}
- (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEventRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestEmitTestEventResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testEmitTestEventRequestWithParams:params completion:
                                                        ^(MTRUnitTestingClusterTestEmitTestEventResponseParams * _Nullable data, NSError * _Nullable error) {
                                                            // Cast is safe because subclass does not add any selectors.
                                                            completionHandler(static_cast<MTRTestClusterClusterTestEmitTestEventResponseParams *>(data), error);
                                                        }];
}
- (void)testEmitTestFabricScopedEventRequestWithParams:(MTRTestClusterClusterTestEmitTestFabricScopedEventRequestParams *)params completionHandler:(void (^)(MTRTestClusterClusterTestEmitTestFabricScopedEventResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self testEmitTestFabricScopedEventRequestWithParams:params completion:
                                                                    ^(MTRUnitTestingClusterTestEmitTestFabricScopedEventResponseParams * _Nullable data, NSError * _Nullable error) {
                                                                        // Cast is safe because subclass does not add any selectors.
                                                                        completionHandler(static_cast<MTRTestClusterClusterTestEmitTestFabricScopedEventResponseParams *>(data), error);
                                                                    }];
}

- (void)readAttributeBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBooleanWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBooleanWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap8WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap8WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeBitmap16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap16WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap16WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeBitmap32WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap32WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap32WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeBitmap64WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap64WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap64WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum8WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                       }];
}
+ (void)readAttributeEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum8WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}

- (void)readAttributeEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum16WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum16WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeFloatSingleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatSingleWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatSingleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeFloatDoubleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatDoubleWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatDoubleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOctetStringWithCompletion:
              ^(NSData * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSData *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSData *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOctetStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSData *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeListInt8uWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListInt8uWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                           ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                           }];
}
+ (void)readAttributeListInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListInt8uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                  completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                              }];
}

- (void)readAttributeListOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListOctetStringWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeListOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListOctetStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeListStructOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListStructOctetStringWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeListStructOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListStructOctetStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeLongOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLongOctetStringWithCompletion:
              ^(NSData * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSData *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSData *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLongOctetStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSData *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCharStringWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSString *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCharStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSString *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeLongCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLongCharStringWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeLongCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLongCharStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeEpochUsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochUsWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                             reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                         }];
}
+ (void)readAttributeEpochUsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochUsWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}

- (void)readAttributeEpochSWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochSWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                            reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                        }];
}
+ (void)readAttributeEpochSWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochSWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                           ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                               // Cast is safe because subclass does not add any selectors.
                                                                                                                               completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                           }];
}

- (void)readAttributeVendorIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIdWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIdWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeListNullablesAndOptionalsStructWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListNullablesAndOptionalsStructWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                                 ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                                 }];
}
+ (void)readAttributeListNullablesAndOptionalsStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListNullablesAndOptionalsStructWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                    ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                                        completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                                    }];
}

- (void)readAttributeEnumAttrWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnumAttrWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                              reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                          }];
}
+ (void)readAttributeEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnumAttrWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}

- (void)readAttributeStructAttrWithCompletionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStructAttrWithCompletion:
              ^(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRTestClusterClusterSimpleStruct *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<MTRTestClusterClusterSimpleStruct *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeStructAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStructAttrWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<MTRTestClusterClusterSimpleStruct *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                       ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                       }];
}
+ (void)readAttributeRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                          ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                              // Cast is safe because subclass does not add any selectors.
                                                                                                                                              completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                          }];
}

- (void)readAttributeListLongOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListLongOctetStringWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeListLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListLongOctetStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeListFabricScopedWithParams:(MTRReadParams * _Nullable)params completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListFabricScopedWithParams:params completion:
                                                             ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                 // Cast is safe because subclass does not add any selectors.
                                                                 completionHandler(static_cast<NSArray *>(value), error);
                                                             }];
}
- (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:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeListFabricScopedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListFabricScopedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeTimedWriteBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTimedWriteBooleanWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}
+ (void)readAttributeTimedWriteBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTimedWriteBooleanWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                      ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                      }];
}

- (void)readAttributeGeneralErrorBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneralErrorBooleanWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeGeneralErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneralErrorBooleanWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeClusterErrorBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterErrorBooleanWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeClusterErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterErrorBooleanWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeUnsupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnsupportedWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                             ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                 // Cast is safe because subclass does not add any selectors.
                                                                                                                                 reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                             }];
}
+ (void)readAttributeUnsupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnsupportedWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}

- (void)readAttributeNullableBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBooleanWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeNullableBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBooleanWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeNullableBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap8WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeNullableBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap8WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

- (void)readAttributeNullableBitmap16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap16WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeNullableBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap16WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeNullableBitmap32WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap32WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeNullableBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap32WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeNullableBitmap64WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap64WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeNullableBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap64WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeNullableInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeNullableInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeNullableInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeNullableInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeNullableInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum8WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeNullableEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum8WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeNullableEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum16WithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum16WithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableFloatSingleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatSingleWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeNullableFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatSingleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeNullableFloatDoubleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatDoubleWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeNullableFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatDoubleWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableOctetStringWithCompletion:
              ^(NSData * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSData *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSData *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeNullableOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableOctetStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSData * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSData *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeNullableCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableCharStringWithCompletion:
              ^(NSString * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSString *>(value), error);
              }];
}
- (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:
                                                                                                                                    ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        reportHandler(static_cast<NSString *>(value), error);
                                                                                                                                    }];
}
+ (void)readAttributeNullableCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableCharStringWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                       ^(NSString * _Nullable value, NSError * _Nullable error) {
                                                                                                                                           // Cast is safe because subclass does not add any selectors.
                                                                                                                                           completionHandler(static_cast<NSString *>(value), error);
                                                                                                                                       }];
}

- (void)readAttributeNullableEnumAttrWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnumAttrWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                  }];
}
+ (void)readAttributeNullableEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnumAttrWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                     ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                     }];
}

- (void)readAttributeNullableStructWithCompletionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableStructWithCompletion:
              ^(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<MTRTestClusterClusterSimpleStruct *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<MTRTestClusterClusterSimpleStruct *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeNullableStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableStructWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(MTRUnitTestingClusterSimpleStruct * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<MTRTestClusterClusterSimpleStruct *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeNullableRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeNullableRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeNullableRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                  // Cast is safe because subclass does not add any selectors.
                                                                                                                                                  reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                              }];
}
+ (void)readAttributeNullableRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                                     completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                 }];
}

- (void)readAttributeNullableRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeNullableRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeNullableRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16sWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                                   reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                               }];
}
+ (void)readAttributeNullableRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16sWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                                  ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                                      completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                                  }];
}

- (void)readAttributeWriteOnlyInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWriteOnlyInt8uWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                    // Cast is safe because subclass does not add any selectors.
                                                                                                                                    reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                }];
}
+ (void)readAttributeWriteOnlyInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWriteOnlyInt8uWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                   ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                       // Cast is safe because subclass does not add any selectors.
                                                                                                                                       completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                   }];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                      ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                          // Cast is safe because subclass does not add any selectors.
                                                                                                                                          reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                      }];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                         ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                             // Cast is safe because subclass does not add any selectors.
                                                                                                                                             completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                         }];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                                     ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                         // Cast is safe because subclass does not add any selectors.
                                                                                                                                         reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                                     }];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                        ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                            // Cast is safe because subclass does not add any selectors.
                                                                                                                                            completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                        }];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:
              ^(NSArray * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSArray *>(value), error);
              }];
}
- (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:
                                                                                                                               ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   reportHandler(static_cast<NSArray *>(value), error);
                                                                                                                               }];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                  ^(NSArray * _Nullable value, NSError * _Nullable error) {
                                                                                                                                      // Cast is safe because subclass does not add any selectors.
                                                                                                                                      completionHandler(static_cast<NSArray *>(value), error);
                                                                                                                                  }];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                            ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                // Cast is safe because subclass does not add any selectors.
                                                                                                                                reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                            }];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                               ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                   // Cast is safe because subclass does not add any selectors.
                                                                                                                                   completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                               }];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:
              ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                  // Cast is safe because subclass does not add any selectors.
                  completionHandler(static_cast<NSNumber *>(value), error);
              }];
}
- (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:
                                                                                                                                 ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                     // Cast is safe because subclass does not add any selectors.
                                                                                                                                     reportHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                 }];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithClusterStateCache:attributeCacheContainer.realContainer endpoint:endpoint queue:queue completion:
                                                                                                                                    ^(NSNumber * _Nullable value, NSError * _Nullable error) {
                                                                                                                                        // Cast is safe because subclass does not add any selectors.
                                                                                                                                        completionHandler(static_cast<NSNumber *>(value), error);
                                                                                                                                    }];
}

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

@end

@implementation MTRBaseClusterSampleMEI

- (void)pingWithCompletion:(MTRStatusCompletion)completion
{
    [self pingWithParams:nil completion:completion];
}
- (void)pingWithParams:(MTRSampleMEIClusterPingParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    if (params == nil) {
        params = [[MTRSampleMEIClusterPingParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = SampleMei::Commands::Ping::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:nil
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}
- (void)addArgumentsWithParams:(MTRSampleMEIClusterAddArgumentsParams *)params completion:(void (^)(MTRSampleMEIClusterAddArgumentsResponseParams * _Nullable data, NSError * _Nullable error))completion
{
    if (params == nil) {
        params = [[MTRSampleMEIClusterAddArgumentsParams
            alloc] init];
    }

    auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) {
        completion(response, error);
    };

    auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs;

    using RequestType = SampleMei::Commands::AddArguments::Type;
    [self.device _invokeKnownCommandWithEndpointID:self.endpointID
                                         clusterID:@(RequestType::GetClusterId())
                                         commandID:@(RequestType::GetCommandId())
                                    commandPayload:params
                                timedInvokeTimeout:timedInvokeTimeoutMs
                       serverSideProcessingTimeout:params.serverSideProcessingTimeout
                                     responseClass:MTRSampleMEIClusterAddArgumentsResponseParams.class
                                             queue:self.callbackQueue
                                        completion:responseHandler];
}

- (void)readAttributeFlipFlopWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)writeAttributeFlipFlopWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion
{
    [self writeAttributeFlipFlopWithValue:(NSNumber * _Nonnull) value params:nil completion:completion];
}
- (void)writeAttributeFlipFlopWithValue:(NSNumber * _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 = SampleMei::Attributes::FlipFlop::TypeInfo;
        TypeInfo::Type cppValue;
                cppValue = value.boolValue;

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

- (void)subscribeAttributeFlipFlopWithParams:(MTRSubscribeParams * _Nonnull)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                               reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFlipFlopWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                           reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SampleMei::Attributes::GeneratedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::GeneratedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                          reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SampleMei::Attributes::AcceptedCommandList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::AcceptedCommandList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::EventList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SampleMei::Attributes::EventList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::EventList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::AttributeList::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SampleMei::Attributes::AttributeList::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::AttributeList::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::FeatureMap::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SampleMei::Attributes::FeatureMap::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::FeatureMap::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::ClusterRevision::TypeInfo;
    [self.device _readKnownAttributeWithEndpointID:self.endpointID
                                         clusterID:@(TypeInfo::GetClusterId())
                                       attributeID:@(TypeInfo::GetAttributeId())
                                            params:nil
                                             queue:self.callbackQueue
                                        completion:completion];
}

- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    using TypeInfo = SampleMei::Attributes::ClusterRevision::TypeInfo;
    [self.device _subscribeToKnownAttributeWithEndpointID:self.endpointID
                                                clusterID:@(TypeInfo::GetClusterId())
                                              attributeID:@(TypeInfo::GetAttributeId())
                                                   params:params
                                                    queue:self.callbackQueue
                                            reportHandler:reportHandler
                                  subscriptionEstablished:subscriptionEstablished];
}

+ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    using TypeInfo = SampleMei::Attributes::ClusterRevision::TypeInfo;
    [clusterStateCacheContainer
        _readKnownCachedAttributeWithEndpointID:static_cast<chip::EndpointId>([endpoint unsignedShortValue])
                                      clusterID:TypeInfo::GetClusterId()
                                    attributeID:TypeInfo::GetAttributeId()
                                          queue:queue
                                     completion:completion];
}

@end

// NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)